﻿<!doctype html public "-//W3C//DTD XHTML 1.0 Transitional//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <meta http-equiv="Content-type" content="text/html;charset=UTF-8" />
    <title>The Apache OpenOffice Project Announces Apache OpenOffice &trade; 3.4</title>

</head>
<body>
<h1>The Apache OpenOffice Project Announces Apache OpenOffice&trade; 3.4</h1>
<p>
<strong>Numerous enhancements to leading Open Source multi-platform, multi-lingual office productivity suite with over 
100M users worldwide; <a
	href="http://download.openoffice.org">downloads now available for Windows, Linux and Macintosh free of charge</a>.</strong>
</p>
<p>
<strong>www.OpenOffice.org &mdash;8 May 2012&mdash;</strong> The Apache OpenOffice Project today announced the 
availability of Apache OpenOffice&trade; 3.4, the first release of OpenOffice under the governance of the Apache Software 
Foundation.
</p>
<p>
Apache OpenOffice is the original open source office productivity suite, designed for professional and consumer use.
</p>
<p>
"With the donation of OpenOffice.org to the ASF, the Foundation, and especially the podling project, was given a daunting 
task: re-energize a community and transform OpenOffice from a codebase of unknown Intellectual Property heritage, to a 
vetted and Apache Licensed software suite," said Jim Jagielski, ASF President and an Apache OpenOffice project mentor. "The 
release of Apache OpenOffice 3.4 shows just how successful the project has been: pulling in developers from over 21 
corporate affiliations, while avoiding undue influence which is the death-knell of true open source communities; 
building a solid and stable codebase, with significant improvement and enhancements over other variants; and, of course, 
creating a healthy, vibrant and diverse user and developer community."
</p>
<p>
Apache OpenOffice is the leading open source office productivity suite, with more than 100 million users worldwide in 
home, corporate, government, research, and academic environments, across 15 languages. Apache OpenOffice 3.4 is <a
href="http://download.openoffice.org">available for download</a> free of charge. OpenOffice 3.4 features:
</p>
<ul>
    <li>
        word processing, spreadsheets, presentation graphics, databases, drawing, and mathematical editing applications support 
        for Windows, Linux (32-bit and 64-bit) and Macintosh operating environments
    </li>
    <li>
        native language support for English, Arabic, Czech, German, Spanish, French, Galician, Hungarian, Italian, Japanese, 
        Dutch, Russian, Brazilian Portuguese, Simplified Chinese, and Traditional Chinese
    </li>
    <li>
        improved ODF support, including new ODF 1.2 encryption options and new spreadsheet functions
    </li>
    <li>
        enhanced pivot table support in Calc
    </li>
    <li>
        enhanced graphics, including line caps, <a href="https://blogs.apache.org/OOo/entry/features_for_graphicobjects_and_oleobjects">shear transformations</a> 
		and <a href="https://blogs.apache.org/OOo/entry/native_svg_support_for_apache">native support</a> for Scalable Vector Graphics (SVG)
    </li>
    <li>
        improvements in performance and quality
    </li>
</ul>
<p>
The complete list of new features, functions, and improvements is available in the <a
href="https://cwiki.apache.org/confluence/display/OOOUSERS/AOO+3.4+Release+Notes">Release Notes</a>.
</p>
<p>
Apache OpenOffice users also benefit from a broad ecosystem of 3rd party products, including over <a
href="http://templates.openoffice.org/">2300 templates</a> and over <a
href="http://extensions.openoffice.org/">800 extensions</a>.
</p>
<h2>Community-Driven Development, The Apache Way</h2>
<p>
The OpenOffice code base was created by Star Division in the 1990's, acquired by Sun Microsystems in 
1999 and later Oracle Corporation in 2010, before being submitted to The Apache Software Foundation mid-2011.
</p>
<p>
Today the project is being developed by an all-volunteer group of developers, testers, translators, and other 
contributors under the ASF's meritocratic process informally dubbed "The Apache Way", and is supported by hundreds of 
Open Source software volunteers from around the world.
</p>
<p>
"Initially released a decade ago, the first release of OpenOffice 3.4 as an Apache project marks an important new chapter in the life of 
	a landmark project," said Stephen O'Grady, Principal Analyst with RedMonk. "Following months of effort, the open source productivity 
	suite is now licensed and built with the intent of courting a large population of users, developers and ISVs worldwide." 	
</p>	
<p>
As a project in the Apache Incubator, Apache OpenOffice is overseen by a Podling Project Management Committee (PPMC) 
that guides its day-to-day operations, community development, and product releases. Apache OpenOffice source code, 
downloads, documentation, mailing lists, and related resources are available at <a href="http://openoffice.apache.org/">http://openoffice.apache.org/</a>
</p>
<p>
For the first official Apache release of OpenOffice, the developer team successfully conformed to the policy defined by 
the Incubator Project Management Committee by identifying, removing and replacing with comparable function those 
libraries with licenses incompatible with Apache Software Foundation license policy.
</p>
<h2>Future Developments</h2>
<p>
Plans for future enhancements by the Project include support for additional native languages, enhanced accessibility, 
usability and performance improvements, and adopting new features and improvements from the upcoming IBM Lotus Symphony 
contribution.
</p>
<p>
The Apache OpenOffice Project Management Committee invites people to join. There are many different area where contribution is most 
welcome. Check out the <a
href="http://openoffice.apache.org/get-involved.html">Get Involved</a> page.
</p>
<p>
"Apache OpenOffice is the leading Open Source office productivity suite with more than 15 years of engineering 
investment. We are pleased and excited to offer OpenOffice fully licensed under the Apache License 2. This offering will 
form the foundation of OpenOffice innovation moving forward here at Apache," said Juergen Schmidt, Apache OpenOffice 
Release Manager and veteran core developer. "With the achievement of this major milestone, we have established a diverse 
and vibrant community with sufficient depth and skills to ably steward this important product into the future. We look 
forward to graduating as an Apache Top Level Project soon."
</p>
<h2>For more information</h2>
<p>
More information on the Apache OpenOffice product can be found at our website, <a
href="http://www.openoffice.org">www.openoffice.org</a>. Information on the Apache OpenOffice project, including 
information on volunteering with the project can be found at our <a
href="http://openoffice.apache.org/">project website</a>.
</p>
<p>
To be added to a mailing list for official OpenOffice-related announcements, send an email to <a
href="mailto:announce-subscribe@openoffice.apache.org">announce-subscribe@openoffice.apache.org</a>. You can also 
follow us on <a href="http://www.facebook.com/ApacheOO">Facebook</a>, <a
href="https://twitter.com/#!/apacheoo">Twitter</a>, <a
href="http://identi.ca/apacheoo">Identi.ca</a> and <a
href="https://plus.google.com/u/0/114598373874764163668/">Google+</a>.
</p>
<h2>About The Apache Software Foundation (ASF)</h2>
<p>
Apache technologies power more than half the Internet, petabytes of data, teraflops of operations, billions of objects, 
and enhance the lives of countless users and developers. Established in 1999 to shepherd, develop, and incubate Open 
Source innovations "The Apache Way", the ASF oversees 150+ projects led by a volunteer community of over 400 individual 
	Members and 3,500 Committers across six continents. For more information, visit <a href="http://www.apache.org/">http://www.apache.org/</a>.
</p>
<p>
"Apache", "Apache OpenOffice", "OpenOffice", and "OpenOffice.org" are either trademarks or registered trademarks of 
	The Apache Software Foundation in the United States and in other countries. All other brands and trademarks are the 
	property of their respective owners.
</p>
<hr/>
<h1>Testimonials</h1> <h2>Community</h2>
<p>
"OpenOffice.org was a revolution in its time as an office tool and its role launching the Open Document Format (ODF) 
standard. We are excited to see OpenOffice succeed at Apache which is recognized for its strong reputation to grow 
excellent projects. This milestone is evidence that the 'Apache Way', which respects the meritocracy of people 
contributing their time and talent to benefit their projects, is the key ingredient that makes Apache OpenOffice ideal 
for everyone." <br/>
— Claudio Filho, member of the Apache OpenOffice Project Management Committee and the Brazilian OpenOffice community
</p>
<p>
"Apache OpenOffice 3.4 is a worthy progression of OpenOffice.org. Many improvements have been completed, which 
originally began for OpenOffice.org, but we have also added a lot of new features, all with usual high quality our users 
have come to expect. Use Apache OpenOffice 3.4 for your personal, business, or education requirements, and reward the 
work of the many volunteers who have made this possible. The Germanophone contributors will continue to support you and 
listen to your questions, requests and suggestions. Together we will continue to shape the future of OpenOffice at 
Apache." <br/>
— Regina Henschel, member of the Project Management Committee and the OpenOffice Germanophone community.
</p>
<p>
"OpenOffice and its large, diverse community now have a new home at Apache. More than 40 volunteers from the Italian 
community helped with translations and quality assurance, to make sure that Apache OpenOffice 3.4 is on par with what 
users have come to expect from the OpenOffice brand. The new license allows for contributions to OpenOffice to be freely 
re-used in other projects, and I am looking forward to cross-project collaboration in the best interest of users." <br/>
— Andrea Pescetti, member of the Project Management Committee and the Italian OpenOffice community
</p>
<p>
"Apache OpenOffice 3.4 is a major milestone for our OpenOffice community in Taiwan, because it is the first release 
our Taiwan local community truly participates, both in its translation and its development. I sincerely invite you to 
download and try our work. It shall bring you the best experience ever." <br/>
— Yang Shih-Ching, member of the Apache OpenOffice Project Management Committee, and the OpenOffice Taiwan community
</p>
<h2>Corporate</h2>
<p>
"These are exciting times! SourceForge has been a trusted partner to the open source community for over a decade, and we 
are proud to be working with the Apache Software Foundation. Release 3.4 of Apache OpenOffice achieves a significant 
milestone for the product and community. Our teams are happy to be contributing and look forward to continued progress. 
Congratulations!” <br/>
— Jeff Drobick, CEO Geeknet Media 
</p>
<p>
"IBM is pleased to contribute to the Apache OpenOffice project licensed under the Apache License v2.  This project 
represents a unique opportunity to innovate and create office productivity documents that meet the needs of social 
businesses.  We look forward to completing the source code contribution of Symphony to Apache OpenOffice in the near 
future."  <br/>
— Kevin Cavanaugh, Vice President, IBM Collaboration Solutions
</p>
<p>
"PSC Group, LLC included Lotus Symphony and OpenOffice in our customer’s solutions for many years. With the move to 
the Apache Software Foundation, PSC has signed up with a Corporate Contributor License Agreement and many of our 
consultants have decided to become Individual Contributors. We look forward to contributing to the next major version 
proposed as Apache OpenOffice 4." <br/>
— John Head, Director, Enterprise Collaboration, PSC Group, LLC
</p>
<p>
"We are working on the Apache OpenOffice project because our goal is to consistently bring business value to users. The 
project will ultimately drive increased productivity as we work towards extending report generation and document 
collaboration from within SugarCRM. When users are more productive, they can focus on the most important task at hand 
which is to deliver a stellar customer experience." <br/>
— Clint Oram, chief technology officer and co-founder of SugarCRM
</p>
</body>
</html>
