<!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>Mailing Lists</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/>
    <h2 id="apache-openoffice-public-mailing-lists">Apache OpenOffice Public Mailing Lists<a class="headerlink" href="#apache-openoffice-public-mailing-lists" title="Permalink">&para;</a></h2>
<p>We welcome you to join our mailing lists and let us know about your thoughts or
ideas about Apache OpenOffice.</p>
<p>Note: These are public mailing lists and anything posted to these lists is archived
and is visible to the public, indexed by search engines, etc. Posts can only
be removed in extraordinary circumstances, in accordance with Apache's <a href="http://www.apache.org/foundation/public-archives.html">Public Forum
Archive Policy</a></p>
<ul>
<li><a href="#using-mailing-lists">Using Mailing Lists</a></li>
<li><a href="#participation-guidelines">Participation Guidelines</a></li>
<li><a href="#users-mailing-list-public">Users Mailing List</a></li>
<li><a href="#api-mailing-list-public">API Mailing List</a></li>
<li><a href="#marketing-mailing-list-public">Marketing Mailing List</a></li>
<li><a href="#announce-mailing-list">Announce Mailing List</a></li>
<li><a href="#development-mailing-list-public">Development Mailing List</a></li>
<li><a href="#recruitment-mailing-list-public">Recruitment Mailing List</a></li>
<li><a href="#documentation-mailing-list-public">Documentation Mailing List</a></li>
<li><a href="#qa-mailing-list-public">Quality Assurance (QA) Mailing List</a></li>
<li><a href="#localization-mailing-list-public">Localization Mailing List</a></li>
<li><a href="#commits-mailing-list">Commits Mailing List</a></li>
<li><a href="#issues-mailing-list">Issues Mailing List</a></li>
<li><a href="#native-lang-lists">Native Language (non-English) Mailing Lists</a></li>
<li><a href="#legacy-openofficeorg-lists">Legacy OpenOffice.org Lists</a></li>
</ul>
<h2 id="using-mailing-lists">Using Mailing Lists<a class="headerlink" href="#using-mailing-lists" title="Permalink">&para;</a></h2>
<p>A mailing list is a way to share information and coordinate with other project members.
When you send an e-mail to a mailing list it is forwarded to all other subscribers to
that mailing list.</p>
<p>Every OpenOffice mailing list has a list address, of the form:
<em>xyz</em>@openoffice.apache.org, where you <strong>replace "<em>xyz</em>" with the actual list name</strong>,
such as "dev" or "qa" or "marketing".</p>
<h3 id="basic-operations">Basic Operations<a class="headerlink" href="#basic-operations" title="Permalink">&para;</a></h3>
<p>There are three basic operations you should know about:</p>
<ul>
<li>To <em>send</em> an e-mail to the mailing list, and have it forwarded to all other
subscribers, send an e-mail to the list's address, <em>xyz</em>@openoffice.apache.org.</li>
<li>To <em>subscribe</em> to the mailing list, so you start receiving all posts to the mailing
list, send an e-mail to <em>xyz</em><a href="mailto:-subscribe@openoffice.apache.org">-subscribe@openoffice.apache.org</a>. You will then receive a
confirmation e-mail. Once you respond to the confirmation e-mail you are subscribed.
Please keep the initial e-mail you receive from <em>xyz</em><a href="mailto:-help@openoffice.apache.org">-help@openoffice.apache.org</a> as it
contains helpful information you may need in the future.</li>
<li>To <em>unsubscribe</em> from the mailing list, so you stop receiving all posts to the
mailing list, send an e-mail to <em>xyz</em><a href="mailto:-unsubscribe@openoffice.apache.org">-unsubscribe@openoffice.apache.org</a>. You will then
receive a confirmation e-mail. Once you respond to the confirmation e-mail you are
unsubscribed.</li>
</ul>
<p>NOTE: Please do not send subscribe/unsubscribe requests to the mailing list itself
(<em>xyz</em>@openoffice.apache.org). You must send these requests to the special
<em>xyz</em>-subscribe and <em>xyz</em>-unsubscribe addresses.</p>
<h3 id="list-moderators">List Moderators<a class="headerlink" href="#list-moderators" title="Permalink">&para;</a></h3>
<p>Each mailing list at OpenOffice has at least two human moderators. If you need
additional help with a mailing list in any way including reporting inappropriate
behavior, you can e-mail the list moderator at <em>xyz</em><a href="mailto:-owner@openoffice.apache.org">-owner@openoffice.apache.org</a> where
<em>xyz</em> is a list name. Example: <a href="mailto:qa-owner@openoffice.apache.org">qa-owner@openoffice.apache.org</a>.</p>
<h2 id="participation-guidelines">Participation Guidelines<a class="headerlink" href="#participation-guidelines" title="Permalink">&para;</a></h2>
<p>We ask all mailing list participants to observe <a href="/list-conduct.html">these conduct guidelines</a>.</p>
<p>Specifically note the request "Use sensible and concise e-mail subject headings". On our
high-traffic lists, especially dev, we encourage the use of e-mail subject tags that
indicate the topic of your post. Consistent use of such tags makes it more likely that
your post will be read by subscribers most interested in that topic. It also faciliates
sorting and filtering by e-mail inbox rules.</p>
<p>Some subject tags often seen on dev include:</p>
<ul>
<li>[www] for posts related to the website</li>
<li>[Repo] for posts related to the source code repository</li>
<li>[download] for posts related to the release download and mirroring infrastruture</li>
<li>[API] for posts related to API specific topics</li>
<li>[EXT] for posts related to Extension specific topics</li>
</ul>
<p>Other useful topic tags can be found by observing traffic on the list or by looking at
the list archives.</p>
<p>In addition to the topic subject tags, there are also tags used to indicate a request:</p>
<ul>
<li>[DISCUSS] indicates a rough idea is being floated, and input is welcome</li>
<li>[PROPOSAL] indicates a specific proposal is being made, and often that Lazy
Consensus is being sought.</li>
<li>[VOTE] indicates that a formal vote is being called. This is rare.</li>
</ul>
<p>Note: it is common for a topic tag and an action tag to be combined, e.g.:</p>
<ul>
<li>[PROPOSAL][Repo] Migration of legacy repository to SVN</li>
<li>[DISCUSS][download] What are our options of mirroring legacy releases?</li>
</ul>
<p>Finally, please keep in mind that all of the above mailing lists are public
and any post you make will likely be archived by a variety of services. The Apache
policy for expunging posts can be found
<a href="http://www.apache.org/foundation/public-archives.html">here</a> but this will only apply
to Apache mail archives, not archives from other services such as Gmane or Markmail.</p>
<h2 id="users-mailing-list-public">Users Mailing List (Public)<a class="headerlink" href="#users-mailing-list-public" title="Permalink">&para;</a></h2>
<p>This list is for users, for questions about OpenOffice, for feature requests, for
discussions about the product and project, etc.</p>
<ul>
<li>Subscribe: <a href="mailto:users-subscribe@openoffice.apache.org">users-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:users-unsubscribe@openoffice.apache.org">users-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?users@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-users/">legacy</a></li>
<li>Third-party Archives: <a href="http://markmail.org/search/list:org.apache.incubator.ooo-users">Markmail</a>, <a href="http://openoffice.2283327.n4.nabble.com/Users-f2814619.html">Nabble</a>, <a href="http://www.mail-archive.com/users@openoffice.apache.org/">Mail Archive</a></li>
</ul>
<h2 id="api-mailing-list-public">API Mailing List (Public)<a class="headerlink" href="#api-mailing-list-public" title="Permalink">&para;</a></h2>
<p>This list is for application developers and other interested in scripting, macros or
developing OpenOffice extensions.</p>
<ul>
<li>Subscribe: <a href="mailto:api-subscribe@openoffice.apache.org">api-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:api@openoffice.apache.org">api@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:api-unsubscribe@openoffice.apache.org">api-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?api@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-api/">legacy</a></li>
<li>Third-party Archives: <a href="http://markmail.org/search/list:org.apache.incubator.ooo-api">Markmail</a>, <a href="http://www.mail-archive.com/api@openoffice.apache.org/">Mail Archive</a></li>
</ul>
<h2 id="marketing-mailing-list-public">Marketing Mailing List (Public)<a class="headerlink" href="#marketing-mailing-list-public" title="Permalink">&para;</a></h2>
<p>This is where the community discusses marketing, branding, communications, event
planning and related activities.</p>
<ul>
<li>Subscribe: <a href="mailto:marketing-subscribe@openoffice.apache.org">marketing-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:marketing@openoffice.apache.org">marketing@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:marketing-unsubscribe@openoffice.apache.org">marketing-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?marketing@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-marketing/">legacy</a></li>
<li>Third-party Archives: <a href="http://markmail.org/search/list:org.apache.incubator.ooo-marketing">Markmail</a>, <a href="http://www.mail-archive.com/marketing@openoffice.apache.org/">Mail Archive</a></li>
</ul>
<h2 id="announce-mailing-list">Announce Mailing List<a class="headerlink" href="#announce-mailing-list" title="Permalink">&para;</a></h2>
<p>Subscribe to this list to receive notice about new releases and other important news
from the project.</p>
<ul>
<li>Subscribe: <a href="mailto:announce-subscribe@openoffice.apache.org">announce-subscribe@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:announce-unsubscribe@openoffice.apache.org">announce-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?announce@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-announce/">legacy</a></li>
<li>Third-party Archives: <a href="http://markmail.org/search/list:org.apache.incubator.ooo-announce">Markmail</a>, <a href="http://www.mail-archive.com/announce@openoffice.apache.org/">Mail Archive</a></li>
</ul>
<p><strong>Note:</strong> Only Apache OpenOffice committers may post to the Announce mailing list.
And, you must use your Apache id and domain to post - for example, send using
<strong><a href="mailto:myapacheid@apache.org">myapacheid@apache.org</a></strong>.</p>
<h2 id="development-mailing-list-public">Development Mailing List (Public)<a class="headerlink" href="#development-mailing-list-public" title="Permalink">&para;</a></h2>
<p>This is where the project community hangs out. This list is used to coordinate
activities and ensure we are all pulling in the same direction. This is a high
traffic list, with an average of 30 posts/day.</p>
<ul>
<li>Subscribe: <a href="mailto:dev-subscribe@openoffice.apache.org">dev-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:dev-unsubscribe@openoffice.apache.org">dev-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?dev@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-dev/">legacy</a></li>
<li>Third-party Archives: <a href="http://www.mail-archive.com/dev@openoffice.apache.org/">Mail Archive</a>, <a href="http://openoffice.2283327.n4.nabble.com/Development-f2916443.html">Nabble</a>, <a href="http://markmail.org/search/list:org.apache.incubator.ooo-dev">Markmail</a> (incomplete)</li>
</ul>
<h2 id="documentation-mailing-list-public">Documentation Mailing List (Public)<a class="headerlink" href="#documentation-mailing-list-public" title="Permalink">&para;</a></h2>
<p>This list is for discussing and developing the OpenOffice documentation.</p>
<ul>
<li>Subscribe: <a href="mailto:doc-subscribe@openoffice.apache.org">doc-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:doc@openoffice.apache.org">doc@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:doc-unsubscribe@openoffice.apache.org">doc-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="http://mail-archives.apache.org/mod_mbox/openoffice-doc/">current</a></li>
<li>Third-party Archives: <a href="http://www.mail-archive.com/doc@openoffice.apache.org/">Mail Archive</a>, <a href="http://markmail.org/search/list:org.apache.openoffice.doc">Markmail</a> (incomplete)</li>
</ul>
<h2 id="qa-mailing-list-public">QA Mailing List (Public)<a class="headerlink" href="#qa-mailing-list-public" title="Permalink">&para;</a></h2>
<p>The list is for bug reports, quality assurance for release, beta tests, manual test,
automated tests, etc. You should subscribe (initiate the procedure by sending an
empty e-mail to the address below, then follow the instructions you will receive by
e-mail) if you don't want to miss important announcements.</p>
<ul>
<li>Subscribe: <a href="mailto:qa-subscribe@openoffice.apache.org">qa-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:qa@openoffice.apache.org">qa@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:qa-unsubscribe@openoffice.apache.org">qa-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?qa@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-qa/">legacy</a></li>
<li>Third-party Archives: <a href="http://www.mail-archive.com/qa@openoffice.apache.org/">Mail Archive</a>, <a href="http://markmail.org/search/list:org.apache.incubator.ooo-qa">Markmail</a> (incomplete)</li>
</ul>
<h2 id="localization-mailing-list-public">Localization Mailing List (Public)<a class="headerlink" href="#localization-mailing-list-public" title="Permalink">&para;</a></h2>
<p>The list is discussion of translation and other aspects of localization, for both
the OpenOffice product, as well as documentation and the website.</p>
<ul>
<li>Subscribe: <a href="mailto:L10N-subscribe@openoffice.apache.org">L10N-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:L10N@openoffice.apache.org">L10N@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:L10N-unsubscribe@openoffice.apache.org">L10N-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?l10n@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-l10n/">legacy</a></li>
<li>Third-party Archives: <a href="http://markmail.org/search/list:org.apache.incubator.ooo-l10n">Markmail</a>, <a href="http://www.mail-archive.com/l10n@openoffice.apache.org/">Mail Archive</a></li>
</ul>
<h2 id="commits-mailing-list">Commits Mailing List<a class="headerlink" href="#commits-mailing-list" title="Permalink">&para;</a></h2>
<p>This is where the community receives automated notifications of any changes to the
Apache OpenOffice code and documentation. This is a moderate traffic list, with an
average of 10 posts/day.</p>
<ul>
<li>Subscribe: <a href="mailto:commits-subscribe@openoffice.apache.org">commits-subscribe@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:commits-unsubscribe@openoffice.apache.org">commits-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?commits@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-commits/">legacy</a></li>
<li>Third-party Archives: <a href="http://www.mail-archive.com/commits@openoffice.apache.org/">Mail Archive</a>, <a href="http://markmail.org/search/list:org.apache.incubator.ooo-commits">Markmail</a> (incomplete)</li>
</ul>
<h2 id="issues-mailing-list">Issues Mailing List<a class="headerlink" href="#issues-mailing-list" title="Permalink">&para;</a></h2>
<p>This is where the community receives automated notifications of all issues that were
created or modified in Bugzilla. Currently this is a moderate traffic list, with an
average of 20 posts/day and will increase in the future.</p>
<ul>
<li>Subscribe: <a href="mailto:issues-subscribe@openoffice.apache.org">issues-subscribe@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:issues-unsubscribe@openoffice.apache.org">issues-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="https://lists.apache.org/list.html?issues@openoffice.apache.org">current</a>, <a href="http://mail-archives.apache.org/mod_mbox/incubator-ooo-issues/">legacy</a></li>
<li>Third-party Archives: <a href="http://www.mail-archive.com/issues@openoffice.apache.org/">Mail Archive</a>, <a href="http://markmail.org/search/list:org.apache.incubator.ooo-issues">Markmail</a> (incomplete)</li>
</ul>
<h2 id="recruitment-mailing-list-public">Recruitment Mailing List (Public)<a class="headerlink" href="#recruitment-mailing-list-public" title="Permalink">&para;</a></h2>
<p>This list is for welcoming new contributors. It coordinates the activities for new
people and tries to help to find the right part. This is a low traffic list.</p>
<ul>
<li>Subscribe: <a href="mailto:recruitment-subscribe@openoffice.apache.org">recruitment-subscribe@openoffice.apache.org</a></li>
<li>Post (after subscription): <a href="mailto:recruitment@openoffice.apache.org">recruitment@openoffice.apache.org</a></li>
<li>Unsubscribe: <a href="mailto:recruitment-unsubscribe@openoffice.apache.org">recruitment-unsubscribe@openoffice.apache.org</a></li>
<li>Apache Archives: <a href="http://mail-archives.apache.org/mod_mbox/openoffice-recruitment/">current</a></li>
<li>Third-party Archives: <a href="http://www.mail-archive.com/recruitment@openoffice.apache.org/">Mail Archive</a></li>
</ul>
<h2 id="native-lang-lists">Native Language (non-English) Mailing Lists<a class="headerlink" href="#native-lang-lists" title="Permalink">&para;</a></h2>
<p>The project has several mailing lists for discussion about OpenOffice in native
(non-English) languages.</p>
<p>Information about available Native Language mailing lists can be found in the page
describing <a href="/native-lang.html">native language resources</a>.</p>
<h2 id="legacy-openofficeorg-lists">Legacy OpenOffice.org Lists<a class="headerlink" href="#legacy-openofficeorg-lists" title="Permalink">&para;</a></h2>
<p>As of March 16th, 2012 the legacy OpenOffice.org mailing lists have been disabled.
Archived posts from these mailing lists are archived on <a href="http://openoffice.markmail.org/">MarkMail</a>.</p>
<p>At the same time the legacy e-mail forwarding agent for openoffice.org e-mail address has
also been shutdown.</p>
<p>If you have been directed to this page from an e-mail bounce notification, the following
guide might be useful for directing your post to an appropriate new mailing list for
the OpenOffice project:</p>
<ul>
<li><a href="mailto:users@openoffice.org">users@openoffice.org</a> posts should be sent to <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a></li>
<li><a href="mailto:discuss@openoffice.org">discuss@openoffice.org</a> posts should be sent to <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a></li>
<li><a href="mailto:dev@openoffice.org">dev@openoffice.org</a> posts should be sent to <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a></li>
<li><a href="mailto:securityteam@openoffice.org">securityteam@openoffice.org</a> posts should be sent to <a href="mailto:security@openoffice.apache.org">security@openoffice.apache.org</a></li>
<li>project marketing related posts should be sent to <a href="mailto:marketing@openoffice.apache.org">marketing@openoffice.apache.org</a></li>
<li>requests to use trademarks should be sent to <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a></li>
<li>anything of a confidential nature should be sent to <a href="mailto:private@openoffice.apache.org">private@openoffice.apache.org</a></li>
<li>support questions related to the OpenOffice product should go to <a href="mailto:users@openoffice.apache.org">users@openoffice.apache.org</a></li>
<li>website related questions should go to <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a></li>
<li>questions on volunteering for the project should go to <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a></li>
<li>press queries should go to <a href="mailto:press@openoffice.apache.org">press@openoffice.apache.org</a></li>
</ul>
<p>For any topic not covered by the above, send your post to: <a href="mailto:dev@openoffice.apache.org">dev@openoffice.apache.org</a></p>

  </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: mailing-lists.md; Template: page; Url: mailing-lists.html -->
</body>
</html>