<!doctype html>
<!--
    Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

         https://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License.
-->
<html lang="en" prefix="og: https://ogp.me/ns#">
  <head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1">
<title>Terms of Use</title>
    <!-- Below Meta Tags Generated via https://www.opengraph.xyz -->
    <!-- If you don't care about social media then remove this section -->
    <!-- Values are set in pelicanconf.py -->
    <!-- HTML Meta Tags -->
    <meta name="description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="keywords" content="OpenOffice, Open Office, Apache OpenOffice, Apache Open Office, OpenOffice.org, Developer, Project, Website, Official, Writer, Calc, Impress, Draw, Base, ODF, Open Document Format">
    <!-- Facebook Meta Tags -->
    <meta property="og:url" content="https://openoffice.apache.org">
    <meta property="og:type" content="website">
    <meta property="og:title" content="Apache OpenOffice">
    <meta property="og:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta property="og:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Twitter Meta Tags -->
    <meta name="twitter:card" content="summary_large_image">
    <meta property="twitter:domain" content="openoffice.apache.org">
    <meta property="twitter:url" content="https://openoffice.apache.org">
    <meta name="twitter:title" content="Apache OpenOffice">
    <meta name="twitter:description" content="The official developer website of the Apache OpenOffice open source project, home of OpenOffice Writer, Calc, Impress, Draw and Base.">
    <meta name="twitter:image" content="https://openoffice.apache.org/images/AOO4_website_logo.png">
    <!-- Above Meta Tags Generated via https://www.opengraph.xyz -->
<link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
<link rel="icon" href="/favicon.ico" type="image/x-icon" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
</head>

<body id="index" class="home">
  <div id="banner">
      <div id="bannerleft"><a alt="Apache OpenOffice" href="/">
          <img id="logo" alt="Apache OpenOffice" src="/images/AOO4_website_logo.png" height="60" width="161"/></a></div>
      <div id="bannercenter">The Free and Open Productivity Suite</div>
  </div>
  <div id="clear"></div>
  <nav class="navbar navbar-expand-sm navbar-dark bg-primary">
<button class="navbar-toggler" type="button"
        data-toggle="collapse" data-target="#navbarSupportedContent"
        aria-controls="navbarSupportedContent" aria-expanded="false"
        aria-label="Toggle navigation">
  <span class="navbar-toggler-icon"></span>
</button>
<div class="collapse navbar-collapse" id="navbarSupportedContent">
  <ul class="navbar-nav mr-auto">
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="generalDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">General</a>
      <ul class="dropdown-menu" aria-labelledby="generalDropdown">
	<li><a class="dropdown-item" href="/index.html">About</a></li>
	<li><a class="dropdown-item" href="/downloads.html">Downloads</a></li>
	<li><a class="dropdown-item" href="/license.html">License</a></li>
	<li><a class="dropdown-item" href="/trademarks.html">Trademarks</a></li>
	<li><a class="dropdown-item" href="/press.html">Press</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/">OpenOffice.org</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="communityDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Community</a>
      <ul class="dropdown-menu" aria-labelledby="communityDropdown">
	<li><a class="dropdown-item" href="/get-involved.html">Get Involved</a></li>
	<li><a class="dropdown-item" href="/orientation/index.html">Orientation</a></li>
	<li><a class="dropdown-item" href="/mailing-lists.html">Mailing Lists</a></li>
	<li><a class="dropdown-item" href="/social.html">Social Networking</a></li>
	<li><a class="dropdown-item" href="/events.html">Events</a></li>
	<li><a class="dropdown-item" href="https://www.openoffice.org/support/">Support</a></li>
	<li><a class="dropdown-item" href="/native-lang.html">Native Language</a></li>
	<li><a class="dropdown-item" href="https://cwiki.apache.org/confluence/display/OOOUSERS/">Planning Wiki</a></li>
	<li><a class="dropdown-item" href="/people.html">People</a></li>
	<li><a class="dropdown-item" href="/community-faqs.html">Community FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="developmentDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Development</a>
      <ul class="dropdown-menu" aria-labelledby="developmentDropdown">
	<li><a class="dropdown-item" href="/source.html">Source Code</a></li>
	<li><a class="dropdown-item" href="/bug-tracking.html">Bug Tracking</a></li>
	<li><a class="dropdown-item" href="/qa.html">Quality Assurance</a></li>
	<li><a class="dropdown-item" href="/translate.html">Translation</a></li>
	<li><a class="dropdown-item" href="/website-local.html">Website</a></li>
	<li><a class="dropdown-item" href="/security.html">Security Reports</a></li>
	<li><a class="dropdown-item" href="/contributing-code.html">Contributing Code</a></li>
	<li><a class="dropdown-item" href="/developer-faqs.html">Developer FAQs</a></li>
      </ul>
    </li>
    <li class="nav-item active dropdown">
      <a class="nav-link dropdown-toggle" href="#" id="projectDropdown"
         role="button" data-toggle="dropdown" aria-expanded="false">Project</a>
      <ul class="dropdown-menu" aria-labelledby="projectDropdown">
	<li><a class="dropdown-item" href="https://blogs.apache.org/OOo/">Project Blog</a></li>
	<li><a class="dropdown-item" href="/pmc-faqs.html">PMC FAQs</a></li>
      </ul>
    </li>
  </ul>
  <div class="navbar-nav" style="padding-top: 0.5rem;">
    <div class="nav-item dropdown dropdown-menu-right active">
      <a class="nav-link dropdown-toggle" href="#"
         role="button" data-toggle="dropdown" aria-haspopup="true"
         aria-expanded="false"><img src="https://www.apache.org/foundation/press/kit/feather.svg"
				    width="32" height="32" class="d-inline-block align-top"
				    alt="Apache Feather">The ASF</a>
      <div class="dropdown-menu dropdown-menu-right">
	<a class="dropdown-item" href="https://www.apache.org/">Website</a>
	<a class="dropdown-item" href="https://www.apache.org/licenses/">License</a>
	<a class="dropdown-item" href="https://www.apache.org/security/">Security</a>
	<a class="dropdown-item" href="https://www.apache.org/events/current-event">Events</a>
	<a class="dropdown-item" href="https://www.openoffice.org/donations.html">Donations</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/sponsorship.html">Sponsorship</a>
	<a class="dropdown-item" href="https://www.apache.org/foundation/thanks.html">Thanks</a>
      </div>
    </div>
  </div>
</div>  </nav>
  <div id="contenta">
    <br/>
    <p>Terms of Use for Apache OpenOffice web site</p>
<ol>
<li>
<p>INTRODUCTION. This Site and its contents are made available by Apache Software Foundation, OpenOffice Project Management Committee (AOO-PMC). These Terms of Use apply to everyone who Uses this Site (as defined below), or who participates in any projects hosted on this Site. PLEASE READ THESE TERMS CAREFULLY FIRST. BY USING THE SITE OR PARTICIPATING IN ANY PROJECTS, YOU ACKNOWLEDGE THAT YOU HAVE READ THE TERMS AND AGREE TO THEM. IF YOU DO NOT WISH TO BE BOUND BY THE TERMS, THEN DO NOT USE THE SITE OR PARTICIPATE IN ANY PROJECTS HOSTED ON THIS SITE.</p>
</li>
<li>
<p>DEFINITIONS. As used here:</p>
<p>a. "Host" means AOO-PMC.</p>
<p>b. "Materials" means source code, code samples, object code, technical materials, documentation , discussion thread postings, weblogs, wikis, data, and any other content, information or technology available on the Site.</p>
<p>c. "Project" means a project hosted on the Site.</p>
<p>d. "Site" means the collection of web pages that can be accessed via this website, as well as any successor web pages or other technology as may be designated by the Host.</p>
<p>e. "Submissions" means any Materials submitted to the Site, including all Projects.</p>
<p>f. "Terms" means these Terms of Use.</p>
<p>g. "Use" and its variants are meant in their broadest sense, including, but not limited to, the acts of using, accessing, receiving, browsing, downloading from, and uploading to. A "User" is a person or entity who Uses the Site.</p>
<p>h. "You" means you personally, as well as the person or entity on whose behalf you are Using the Site.</p>
</li>
<li>
<p>ACCESS TO THE SITE AND THINGS YOU FIND HERE.
This section refers to the Materials found on the Site, as defined above.</p>
<p>a. Other Licenses/Terms. Some of the Materials may be accompanied by their own licenses or terms of use. With respect to Your rights in and obligations regarding such Materials, and to the extent there is a conflict, those licenses or terms of use take precedence over these Terms, and you agree to be bound accordingly. With respect to any other matters, including but not limited to Your Use of this Site, submission of Materials hereto, and obligations to the Host, these Terms take precedence over any conflicting terms.</p>
<p>b. Use at Your Own Risk. You understand that the Host does not pre-screen Materials, and You agree to assume all risks in Using them. These risks include, but are not limited to, errors, viruses, worms, time-limited software that expires without notice, and the possibility that the Materials infringe or misappropriate the intellectual property rights of others. You agree to assume all such risks.</p>
<p>c. Don't Blame the Messenger. You understand that Materials may contain the opinions of others and You do not hold the Host responsible for such opinions.</p>
<p>d. Copyright Infringement. If You believe that any Materials infringe Your copyrights, please follow the procedure set forth at Apache Software Foundation legal affairs website: <a href="http://apache.org/legal/">http://apache.org/legal/</a>.</p>
<p>e. Management of Materials and Access. You agree that the Host has sole discretion in deciding whether to accept and post Materials, and that the Host may delete Materials for any reason (including no reason) whatsoever. You understand that access to the Site may be limited for technical reasons, that outages may occur, and that the Host has no obligation to store or back up any Materials. You agree that the Host has the right to restrict or terminate, in their sole discretion, access to the Site for any reason, including their belief that a User has violated these Terms.</p>
<p>f. Links to Other Sites. You understand that this Site may provide links to other sites or content that is not hosted or managed by the Host, and you agree that the Host has no control over, responsibility or liability whatsoever relating to any such sites or content, including Your Use of them.</p>
</li>
<li>
<p>THINGS YOU SUBMIT TO THE SITE. This Site offers many opportunities for You to contribute Materials to the on this site. In addition to the other terms found here, the following terms apply to any Submissions made by You ("Your Submissions").</p>
<p>a. You Take Responsibility for Your Submissions. You warrant that You have all rights needed to provide Your Submissions to the Host for posting to the Site in accordance with the Terms and to grant the licenses set forth in sections 4.b and 4.c. You agree that You will make all reasonable efforts to ensure that Your Submissions:  do not infringe, misappropriate or violate the intellectual property rights or privacy interests of others; (ii) are not confidential or trade secret information, or subject to anyone's privacy interests; (iii) are not inaccurate, harmful, obscene, pornographic, defamatory, racist, or otherwise objectionable to a reasonable User; and (iv) do not violate any law, ordinance, or regulation of any country, state or locality. YOU AGREE THAT YOU, AND NOT THE HOST, ARE FULLY RESPONSIBLE FOR YOUR SUBMISSIONS AND THAT YOU, AND NOT THE HOST, ARE LIABLE FOR ANY AND ALL CLAIMS ARISING OUT OF THEM.</p>
<p>b. Source Code Submissions. You agree that any source code You contribute to a Project will be submitted under, and subject to, the license posted for that Project. If no license is posted, You agree that Your Submission will be governed by the Apache License, Version 2.0, which terms can be found at <a href="http://opensource.org/licenses/apache2.0.php">http://opensource.org/licenses/apache2.0.php</a>. You acknowledge that You are responsible for including all applicable copyright notices and licenses with Your Submissions, and that You assume the risks of failing to do so, including the potential loss of Your rights to Your Submissions.</p>
<p>c. Other Submissions. (This Section 4.c applies to all Submissions other than source code contributed to a Project, which is governed by the preceding section.) The Host does not claim ownership of Your Submissions. However, in order to fulfill the purposes of this Site, You must give the Host and all Users the right to post, access, evaluate, discuss, and refine Your Submissions.</p>
<p>In legalese: You hereby grant to the Host and all Users a royalty-free, perpetual, irrevocable, worldwide, non-exclusive and fully sub-licensable right and license under Your intellectual property rights to reproduce, modify, adapt, publish, translate, create derivative works from, distribute, perform, display and use Your Submissions (in whole or part) and to incorporate them in other works in any form, media, or technology now known or later developed, all subject to the obligation to retain any copyright notices included in Your Submissions. All Users, the Host, and their sublicensees are responsible for any modifications they make to the Submissions of others.</p>
<p>d. Private Projects. With respect to a Project that is designated as "Private," the preceding license for "Other Submissions" is limited to Users who have access to the Project, and such rights may only be sublicensed to other Users with authorized access to the Project.</p>
<p>e. Other Licenses/Terms. Some Projects are governed by their own terms regarding Submissions and may require You to sign agreements (such as an Apache Software Foundation Individual Contributor License Agreement) licensing Your rights in Your Submissions. In all such cases, and to the extent there is a conflict, the terms of those Projects and agreements take precedence over these Terms.</p>
<p>f. Privacy. You consent to the collection, processing and storage by the Host of any personal information provided by You in accordance with the terms of AOO-PMC Privacy Policy, which is available at <a href="/privacy.html">https://openoffice.apache.org/privacy.html</a>. You agree to comply with all applicable laws and regulations, and the terms of Apache OpenOffice Privacy Policy, with respect to any use by You of any personal information in connection with this Site.</p>
</li>
<li>
<p>MISCELLANEOUS.</p>
<p>a. Disclaimer of Warranties. YOUR USE OF THE SITE IS AT YOUR SOLE RISK. THE SITE, INCLUDING ALL MATERIALS FOUND ON IT, IS PROVIDED ON AN "AS IS," "AS AVAILABLE" AND "WITH ALL FAULTS" BASIS. THE HOST DISCLAIMS ALL EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS, AND WARRANTIES OF ANY KIND, INCLUDING ANY IMPLIED WARRANTY OR CONDITION OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A PARTICULAR PURPOSE, OR NONINFRINGEMENT. THE HOST MAKES NO REPRESENTATIONS, WARRANTIES, CONDITIONS OR GUARANTEES AS TO THE USEFULNESS QUALITY, SUITABILITY, TRUTH, ACCURACY OR COMPLETENESS OF THE SITE. YOU AGREE TO ASSUME ALL RISK OF LOSS OR LIABILITY FOR THE USE OF THIS SITE OR ANY MATERIALS ON IT.</p>
<p>b. Limitation of Liability. TO THE FULLEST EXTENT PERMITTED BY LAW, THE HOST IS NOT LIABLE FOR ANY DIRECT, INDIRECT, PUNITIVE, SPECIAL, INCIDENTAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES (INCLUDING, WITHOUT LIMITATION, LOSS OF BUSINESS, REVENUE, PROFITS, GOODWILL, USE, DATA, ELECTRONICALLY TRANSMITTED ORDERS, OR OTHER ECONOMIC ADVANTAGE) ARISING OUT OF OR IN CONNECTION WITH THE SITE OR MATERIALS, EVEN IF THE HOST HAS PREVIOUSLY BEEN ADVISED OF, OR REASONABLY COULD HAVE FORESEEN, THE POSSIBILITY OF SUCH DAMAGES, HOWEVER THEY ARISE, WHETHER IN BREACH OF CONTRACT OR IN TORT (INCLUDING NEGLIGENCE). TO THE EXTENT THAT ANY JURISDICTION DOES NOT ALLOW THE EXCLUSION OR LIMITATION OF DIRECT, INCIDENTAL OR CONSEQUENTIAL DAMAGES, PORTIONS OF THE ABOVE LIMITATION OR EXCLUSION MAY NOT APPLY.</p>
<p>c. Trademarks. All logos and trademarks contained on this Site are and remain the property of their respective owners. No licenses or other rights in or to such logos and/or trademarks are granted to You by these Terms.</p>
<p>d. Changes to Terms. These Terms may be changed or updated by the Host without notice.</p>
<p>e. Export Compliance. You agree that U.S. export control laws and other applicable export and import laws govern your Submissions and use of the Site, Materials and Submissions, including technical data; additional information can be found on <a href="http://apache.org/dev/crypto.html">http://apache.org/dev/crypto.html</a>. You agree that neither the Materials and Submissions nor any direct product thereof will be exported, directly, or indirectly, in violation of these laws, or will be used for any purpose prohibited by these laws including, without limitation, nuclear, chemical, or biological weapons proliferation.</p>
<p>f. Governing Law. These Terms of Use are governed by the substantive and procedural laws of Delaware.</p>
<p>g. General. You agree that these Terms of Use are the complete agreement for the Site, Materials and Submissions, and these Terms of Use supersedes all prior or contemporaneous agreements or representations. If any term of these Terms of Use is found to be invalid or unenforceable, the remaining provisions will remain effective</p>
</li>
</ol>

  </div>

  <footer class="navbar-expand-lg navbar-light bg-light">
    <div class="footer" id="footer">
        <div class="container-fluid">
          Copyright &copy; 2011-2021 The Apache Software Foundation,
          Licensed under the
          <a href="https://www.apache.org/licenses/LICENSE-2.0">Apache License, Version 2.0.</a> | <a href="/contact.html">Contact Us</a> | <a href="/terms.html">Terms of Use</a> | <a href="/privacy.html">Privacy</a>
          <br/>
          Apache, OpenOffice, OpenOffice.org and the seagull logo are registered trademarks of The Apache Software Foundation.
          The Apache feather logo is a trademark of The Apache Software Foundation.
          Other names appearing on the site may be trademarks of their respective owners.
        </div><!-- #container-fluid -->
        <div class="row container-fluid">
          <div class="col-sm">
            <a href="https://www.apache.org/">
              <img src="https://www.apache.org/img/asf_logo.png" alt="The Apache Software Foundation" style="border: 0; margin-top: 2px" width="200" height="82">
            </a>
          </div>
          <div class="col-sm center-align">
            <a href="https://www.apache.org/foundation/contributing.html">
              <img src="https://www.apache.org/images/SupportApache-small.png" alt="Support The ASF" height="80" width="80">
            </a>
          </div>
          <div class="col-sm right-align">
            <a class="acevent" data-format="wide" data-mode="light" data-event="random"></a>
          </div>
        </div>
    </div>
  </footer>
  <!-- Start load of stylesheets (will need to upgrade periodically) -->
  <link rel="stylesheet"
	href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T"
	crossorigin="anonymous">
  <link rel="stylesheet"
	href="https://cdnjs.cloudflare.com/ajax/libs/github-markdown-css/3.0.1/github-markdown.min.css"
	crossorigin="anonymous">
  <link href="/theme/css/openoffice.css" rel="stylesheet" type="text/css">
  <!-- End stylesheets -->
  <!-- Start the loading of javascript frameworks (will need to upgrade periodically) -->
  <script src="https://www.apachecon.com/event-images/snippet.js"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/jquery/3.6.0/jquery.slim.min.js"
	  integrity="sha512-6ORWJX/LrnSjBzwefdNUyLCMTIsGoNP6NftMy2UAm1JBm6PRZCO1d7OHBStWpVFZLO+RerTvqX/Z9mBFfCJZ4A=="
	  crossorigin="anonymous"></script>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
	  integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1"
	  crossorigin="anonymous"></script>
  <script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
	  integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM"
	  crossorigin="anonymous"></script>
  <!-- End the loading of javascript frameworks -->

  <!-- Source: terms.md; Template: page; Url: terms.html -->
</body>
</html>