<html><head>
<meta HTTP-EQUIV="content-type" CONTENT="text/html; charset=UTF-8">
</head>
<body>
<h3>DEVELOPER RELEASE OF THE OPENOFFICE.ORG OFFICE SUITE FOR MAC OS X NOW AVAILABLE 
</h3>
<h4> Community Development Reaches Milestone of the Mac OS X Port of OpenOffice.org 
  Office Suite </h4>
<p> May 7, 2002 - The Openoffice.org community (<a href="/">/</a>) 
  today announced the availability of the first milestone build of the Mac OS 
  X port of the OpenOffice productivity suite. This build uses the X11 Windowing 
  System from <a href="http://www.xfree86.org">XFree86.org</a> to run on either 
  Mac OS X or Darwin, and is <a href="http://porting.openoffice.org/mac/ooo-osx_downloads.html">available 
  today</a> for developers interested in helping finish the port. </p>
<p> &#8220;I have been astonished at the speed and quality of the work the community 
  has done. We have been working together in a tight, efficient ensemble, and 
  have now something we can use,&quot; said Ed Peterlin, Community developer, 
  OpenOffice.org. &quot;This is exciting for me as a Mac user -- it's been incredibly 
  fun to get this far -- and know that we will be able to finish this with just 
  a little more help.&quot; </p>
<p> &quot;Apple encourages Open Source development, and supports the open source 
  community through the Darwin Project,&quot; said Ron Okamoto, Apple's vice president 
  of Worldwide Developer Relations. &quot;Apple is delighted that a Mac OS X port 
  of the major open source office suite, OpenOffice.org 1.0, has progressed so 
  far so quickly.&quot; </p>
<p> Earlier this month, the OpenOffice.org community announced <a href="../dev_docs/source/1.0.0/index.html">OpenOffice.org 
  1.0</a>, the open source office suite, developed over a period of 18 months 
  through the global, collaborative effort of many thousands of volunteers. The 
  OpenOffice.org 1.0 office suite features key desktop applications, &#8211; including 
  word processor, spreadsheet, presentation, and drawing programs &#8211; in more 
  than 25 languages. </p>
<p> The code for the Mac OS X port of OpenOffice.org has been in development by 
  the community since April 2001, when the code base was released by Sun Microsystems, 
  Inc. The current release, a pre-alpha release is targeted to developers familiar 
  with developing for the Mac OS X platform. </p>
<p> &quot;The developer release of OpenOffice for Mac OS X is a great demonstration 
  of the power of Open Source software and its ability to support multiple platforms.&quot; 
  said Zaheda Bhorat, Community Manager, OpenOffice.org, Sun Microsystems Inc. 
  &quot;Combining the enthusiasm and expertise of the OpenOffice.org community 
  and the UNIX-based, open standards nature of Mac OS X - such as its support 
  for popular Open Source software like X11 and gcc - enabled us to add exciting 
  new platforms like Mac OS X to our large and growing list of platforms.&quot; 
</p>
<p> The OpenOffice.org 1.0 software runs stably and natively on multiple platforms, 
  including Linux, PPC Linux, Solaris, Windows and other flavors of Unix. The 
  Mac OS X developer release uses a ZeroG installer (http://www.ZeroG.com). The 
  OpenOffice.org community wishes to thank ZeroG in this key contribution to delivering 
  this port. </p>
<p> The Max OS X build is currently available as an alpha release in English only, 
  although the OpenOffice.org 1.0 is currently available in more than 25 languages. 
  It is only a matter of time, once this port is completed, that the OpenOffice.org 
  community will implement the localizations. </p>
<p> Developers interested in contributing to making this exciting port a part 
  of the standard OpenOffice.org suite offering can find the tools and resources 
  on the OpenOffice.org site. The next step, now that the port has advanced to 
  this stage, is to create a beta release using the Aqua interface for end users 
  to help finalize. And the OpenOffice.org community is willing to make it happen. 
</p>
<h4><br>
  About OpenOffice.org </h4>
<p> OpenOffice.org is the home of the open source project and its community of 
  developers, users and marketers responsible for the on-going development of 
  the OpenOffice.org 1.0 product. The mission of OpenOffice.org is to create, 
  as a community, the leading international office suite that will run on all 
  major platforms and provide access to all functionality and data through open-component 
  based APIs and an XML-based file format. Additional ports, such as FreeBSD, 
  IRIX and Mac OS X are in various stages of completion by developers and end-users 
  in the OpenOffice.org community. OpenOffice.org 1.0 is written in C++ and has 
  documented API's licensed under the GNU Lesser General Public License (LGPL) 
  and Sun Industry Standards Source License (SISSL) open source licenses. </p>
<p> OpenOffice.org is the largest open source project, with over 7.5 million lines 
  of code. To date, more than 4.5 million downloads of earlier versions of OpenOffice.org 
  1.0 have taken place. With the release of the 1.0 version, the OpenOffice.org 
  community expects that number to grow significantly, as businesses and individuals 
  around the world explore the free alternative to proprietary office suites. 
</p>
<p> Copyright The OpenOffice.org community (<a href="/">www.openoffice.org</a>) 
</p>
<p>&nbsp; </p>
</body>
</html>

