<!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>Source Control</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>As of August, 2019, we use GIT for version control. You can <a href="https://gitbox.apache.org/repos/asf?p=openoffice.git">browse our
repository</a> using the "tree" view from gitbox in your web browser. The <a href="https://github.com/apache/openoffice#readme">README.md</a> at github.com provides useful information on how to download and build Apache OpenOffice.</p>
<p>The previous svn repository, now read only, using <a href="https://subversion.apache.org/">Apache Subversion</a> for version control is <a href="https://svn.apache.org/viewvc/openoffice/trunk/">still viewable</a> in your web browser.</p>
<p>Currently, subversion is still used for the two OpenOffice web sites.
See our <a href="/svn-basics.html">Subversion Basics</a>
for more information on using subversion (svn) for the Apache OpenOffice project.</p>
<!--- For further information see the [Apache Source Code Repository][3] page.-->
<h2 id="getting-the-source-code">Getting the source code<a class="headerlink" href="#getting-the-source-code" title="Permalink">&para;</a></h2>
<h3 id="using-git">Using GIT<a class="headerlink" href="#using-git" title="Permalink">&para;</a></h3>
<!--- You can use our git repository for downloading source but not committing (read only):
    [https://github.com/apache/openoffice](https://github.com/apache/openoffice)-->
<p>Instructions provided in <a href="https://github.com/apache/openoffice">README.md</a> from github.com can be used successfully to get a local copy of the complete source for Apache OpenOffice.</p>
<h3 id="using-svn-applies-to-code-through-july-2019">Using SVN (applies to code through July, 2019)<a class="headerlink" href="#using-svn-applies-to-code-through-july-2019" title="Permalink">&para;</a></h3>
<p>This will get you everything, including the language files:</p>
<pre><code>svn co https://svn.apache.org/repos/asf/openoffice/trunk aoo
</code></pre>
<p>Including SVN overhead, this requires approximately 4 GB of storage.</p>
<h3 id="source-archive-of-the-latest-release">Source archive of the latest release<a class="headerlink" href="#source-archive-of-the-latest-release" title="Permalink">&para;</a></h3>
<p>An archive of the source for the latest release can be obtainted from the Apache Software Foundation repository:
<a href="https://archive.apache.org/dist/openoffice/">https://archive.apache.org/dist/openoffice</a></p>
<h2 id="browsingsearching-source-code">Browsing/Searching Source Code<a class="headerlink" href="#browsingsearching-source-code" title="Permalink">&para;</a></h2>
<!--- We have an instance of [Atlassian FishEye][4] for source browsing, searching,
reporting and visualization of main trunk (main development area).-->
<p>We host an <a href="http://opengrok.openoffice.org/">OpenGrok</a> instance for our
main repository areas.</p>
<h2 id="building-and-running">Building and Running<a class="headerlink" href="#building-and-running" title="Permalink">&para;</a></h2>
<p>See the <a href="https://wiki.openoffice.org/wiki/Documentation/Building_Guide_AOO">Apache OpenOffice Building Guide page</a>
for an overview on building.</p>
<p>The <a href="https://cwiki.apache.org/confluence/display/OOOUSERS/Development+Snapshot+Builds#DevelopmentSnapshotBuilds-buildflags">Development Snapshots builds</a> page, pre-release builds, also provide additional information on building.</p>
<h2 id="testing-developer-installation-sets">Testing Developer Installation Sets<a class="headerlink" href="#testing-developer-installation-sets" title="Permalink">&para;</a></h2>
<p>See <a href="https://cwiki.apache.org/confluence/display/OOOUSERS/Development+Snapshot+Builds#DevelopmentSnapshotBuilds-fullsets">Development Snapshot Builds: Full installation sets</a>, pre-release builds, or <a href="https://www.openoffice.org/download/devbuilds.html">Development Builds</a>, nightly builds from the buildbots, for complete installation sets for available platforms.</p>
<p>Install developer builds to a new directory if you don't want to overwrite your
existing Apache OpenOffice installation.</p>
<ul>
<li>Linux: Create a new directory for the AOO developer install.
Install the RPM pack with --prefix="some new AOO directory" option.</li>
<li>Windows: Use the custom install option, and choose a new directory location for the
AOO developer install.</li>
<li>Mac: create a new folder for AOO developer install. Download the ".dmg" file there, and install
to the new directory.</li>
</ul>
<h2 id="code-and-contribution-statistics">Code and Contribution Statistics<a class="headerlink" href="#code-and-contribution-statistics" title="Permalink">&para;</a></h2>
<!--- Our SVN tree is read by the [Open Hub tracker][6] to generate some various statistics.
Note that the migration from the legacy Mercurial repository to SVN at Apache has
caused pre-existing files to be double-counted. But the contribution history should
be intact.-->
<p><a href="https://gitbox.apache.org/repos/asf?p=openoffice.git">The Apache OpenOffice Gitbox site</a> provides useful statistics on code contributions and changes.</p>
<h2 id="special-development-branches">Special Development Branches<a class="headerlink" href="#special-development-branches" title="Permalink">&para;</a></h2>
<p>For larger, extensive code modifications, specialized branches are created. These branches can also be found in our git repository.</p>
<!--- You can find out more information on them from the Wiki [Source Code](https://wiki.openoffice.org/wiki/Source_Code) page.-->

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