<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <title>Java and Apache OpenOffice</title>
  <style type="text/css">
  /* <![CDATA[ */
  /*-------------------- Exceptions on standard css -----------------------*/
  @import "/css/styles.css";
  @import "/css/exceptions.css";
  /* ]]> */
  </style>
</head>

<body>

<h1>Java and Apache OpenOffice</h1>

<h3>Why Do I Need Java to Use Apache OpenOffice?</h3>

<p>Java is required for complete OpenOffice functionality. Java is mainly required for the HSQLDB
database engine (used by our database product Base) and to make use of accessibility and assistive technologies.
Furthermore some wizards rely on Java technology. See additional topics pertaining to the use of Java in OpenOffice
and Apache OpenOffice in the
<a href="https://wiki.openoffice.org/wiki/Documentation/FAQ/Installation">Installation FAQ</a>.
</p>

<p>So what does this mean exactly? Base (the database component) relies completely on Java technologies to run, but other
programs (like Writer, Calc and Impress) only need Java for special functionality. If you do not need to use Base and do
not want to use any of the Wizards, then you do not need to have Java installed and configured for running Apache
OpenOffice (and older versions of OpenOffice.org). You can completely prevent OpenOffice from prompting you about the use
of Java by telling OpenOffice not to use a Java runtime environment (JRE). From the OpenOffice main menu use:
<strong>"Tools - Options - OpenOffice - Java"</strong>, and uncheck "Use a Java runtime environment". However, we do recommend
that you have a JRE on your system to take full advantage of OpenOffice's features without any issues.
</p>

<p><b>Legacy versions of OpenOffice.org 3.3.0 and older included a JRE packaged with the download. Apache OpenOffice
3.4.0 and newer do not!</b>
</p>

<h3>Which Java Version Do I Need to Use Apache OpenOffice?</h3>

<p>You will need to have a JRE version (32-bit or 64-bit) that is compatible with the architecture of the Apache
OpenOffice version you downloaded. If you already have a JRE installed on your system that satisfies this requirement in
one of the standard areas for Java installation, OpenOffice should detect this installation and let you choose it for use
in OpenOffice via <strong>"Tools - Options - OpenOffice - Java"</strong> (macOS: <strong>"OpenOffice - Preferences
- OpenOffice - Java"</strong>). If you have a JRE installed that is not detected, you should be able to add it through this
same menu. And, you can install a JRE or configure OpenOffice to use Java at any time to get missing functionality to work.
</p>

<p></p>

<p style="background: #FBD864; padding: 10px 15px 10px 15px; border-radius: 10px; ">
<img src="/cachedimages/exclamation-icon.png" style="margin: 0px 2px 0px 0px;" height="16" width="16" />
<b>Important note for Windows users:</b>
</br>
The Windows version of OpenOffice is 32-bit and therefore it requires a 32-bit JRE. Even when you have a Windows version
with 64-bit installed.<br>
Furthermore you have to install a 32-bit JRE - additionally or instead - when you already have a
64-bit JRE installed.
</p>

<h3>Where Can I Get Java?</h3>
<p>The current versions of Apache OpenOffice work reliably with a variety of JREs including
<a href="https://java.com">Oracle Java, versions 6, 7 and 8</a>,
<a href="https://openjdk.java.net/">openJDK, versions 6, 7 and 8</a> and
<a href="https://adoptium.net/">Adoptium OpenJDK, versions 8 and 11</a>. Feel free to download a JRE from either of these sites
if you feel you need this functionality.
</p>

<p>Please report any problems you experience with using Java on OpenOffice through our bug reporting system,
<a href="https://bz.apache.org/ooo/">Bugzilla</a>, or one of the other support venues listed in the
<a href="https://www.openoffice.org/support/">Apache OpenOffice Support</a> webpage, either the users list or forums.
</p>

<p>For installing Java on Windows machines, one might appreciate:
<a href="https://java.com/en/download/help/windows_offline_download.xml">Download Instructions for Windows offline</a>.
</p>

</body>
</html>
