<!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" xml:lang="fr" lang="fr">
<head itemscope itemtype="http://schema.org/Article">
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
  <meta property="og:title" content="Télécharger Apache OpenOffice" />
  <meta property="og:description" content="Rejoignez la révolution OpenOffice, la suite de productivité bureautique gratuite avec plus de 310 millions de téléchargements fiables." />
  <meta property="og:keywords" content="Apache OpenOffice, OpenOffice, Apache Open Office, Download, Official, Official Download, Open Office, OpenOffice.org" />
  <meta property="og:image" content="https://www.openoffice.org/images/AOO_logos/AOO-Logo-Download.png" />
  <meta name="description" content="Page officielle pour le téléchargement Apache OpenOffice . Rejoignez la révolution OpenOffice, la suite de productivité bureautique gratuite avec plus de 310 millions de téléchargements fiables." />
  <link rel="shortcut icon" href="/favicon.ico" type="image/x-icon" />
  <link rel="icon" href="/favicon.ico" type="image/x-icon" />
  <title>Téléchargement Apache OpenOffice - Site Officiel</title>
  <script src="/download/globalvars.js"></script>
  <script src="/download/msg_prop_l10n_en.js"></script>
  <script src="./msg_prop_l10n_fr2.js"></script>
  <script src="/download/languages.js"></script>
  <script src="/download/release_matrix.js"></script>
  <script src="/download/boxed_download.js"></script>
  <script src="/download/download.js"></script>
  <style>
  /* <![CDATA[ */
  /*-------------------- Exceptions on standard css -----------------------*/
  @import "/download/styles.css";
  @import "/download/exceptions.css";
  /* ]]> */
  </style>
  <script>
    if ( window.document.referrer.indexOf( "shell.windows.com" ) != -1 ) {
       location.href = "/why/why_odf.html";
    }

    function share( platform ) {
      // _gaq.push( ['_trackEvent', 'social', 'shareDownload', platform] ); 

      if ( platform == 'apacheblog' ) {
        window.open( 'https://blogs.apache.org/OOo/', '_blank' );
      } else if ( platform == 'facebook' ) {
        window.open( 'https://www.facebook.com/sharer/sharer.php?u=https%3A%2F%2Fwww.openoffice.org%2Fdownload%2F', '_blank', 'toolbar=0, status=0, width=580, height=325' );
      } else if ( platform == 'twitter' ) {
        window.open( 'https://twitter.com/intent/tweet?url=https%3A%2F%2Fwww.openoffice.org%2Fxx%2Fdownload%2F&text=Join+the+OpenOffice+revolution%2C+the+free+office+productivity+suite+with+over+310+million+trusted+downloads.', '_blank', 'toolbar=0, status=0, width=580, height=325' );
      }
    }
  </script>
</head>

<body>

<div itemscope>
  <span itemprop="name" content="Télécharger Apache OpenOffice"></span>
  <span itemprop="description" content="Rejoignez la révolution OpenOffice, la suite de productivité bureautique gratuite avec plus de 310 millions de téléchargements fiables."></span>
  <span itemprop="keywords" content="Apache OpenOffice, OpenOffice, Apache Open Office, Télécharger, Download, Officiel, Téléchargement Officiel, Official, Official Download, Open Office, OpenOffice.org"></span>
  <span itemprop="image" content="https://www.openoffice.org/images/AOO_logos/AOO-Logo-Download.png"></span>
</div>

<div class="overall_optionset">

  <div class="optionset">

    <!-- Text above the first colored box -->
    <script>
      <!--
      // The text in the H1 tag is intentionally shown as "display: none" (do not display).
      // This is to please accessibility tools like a screen reader.
      document.write( "<h1 style='display: none;'>" + l10n.dl_headline_text + "</h1>" );
      //-->
    </script>

    <!-- Green: Stable release -->
    <!-- Download via select boxes -->
    <script>
      <!--

      // Set a specific language ISO code to force to assemble a certain localized build as download link.
      // Changed: The variable can now be found in the "msg_prop_l10n_<ISO_code>.js".

      // Get the download box from a separate file.
      DL.createDownloadBox();

      // Fill the select boxes and wait for the user's choice.
      DL.init( 1 );

      // entourage.initialize();

      //-->
    </script>

    <!-- Green: Stable release: No JavaScript enabled -->
    <noscript>
	<div class="first button green-sel" id="optionitem2">
	  <div class="green-sel-icon">
	  </div>
	  <h2>
	    <a style="cursor: pointer;" href="https://sourceforge.net/projects/openofficeorg.mirror/files/"
	      title="Choisissez parmi toutes les plateformes, langues, packs de langues à télécharger.">
	      Téléchargements Apache OpenOffice - Site officiel
	    </a>
	  </h2>
	  <p>
	    <a style="cursor: pointer;" href="https://sourceforge.net/projects/openofficeorg.mirror/files/"
	      title="Choisissez parmi toutes les plateformes, langues, packs de langues à télécharger.">
	      Le navigateur semble avoir désactivé JavaScript. Cette technique est utilisée pour montrer le réel
			lien de téléchargement. Si vous voulez quand même télécharger Apache OpenOffice, cliquez sur ce texte pour choisir
			à partir de la page Web de téléchargement alternatif. Vous devrez naviguer vers
               le sous-dossier<em>version</em>/binaires/<em>langue</em>  et télécharger le fichier nommé
              Apache_OpenOffice_<em>version</em>_<em>os</em>_<em>platform</em>_<em>package</em>_<em>language</em>.<em>ext</em>.
              Nous nous excusons pour le désagrément.
	    </a>
	  </p>
	</div>
      </noscript>

      <!-- Light Blue: Share download with social networks -->
      <script>
	<!--
	// Get the share box from a separate file.
	DL.createShareBox();
	//-->
      </script>

      <!-- Blue: Extensions -->
      <script type="text/javascript">
	<!--
	// Get the extensions box from a separate file.
	DL.createExtensionsBox();
	//-->
      </script>

      <!-- Blue: Templates -->
      <script type="text/javascript">
	<!--
	// Get the templates box from a separate file.
	DL.createTemplatesBox();
	//-->
      </script>

    </div> <!-- class "optionset" -->

    <div class="additionalinformation">

      <!-- Navigation bar -->
      <script type="text/javascript">
	<!--
	// Get the navigation bar from a separate file.
	DL.createNavigationBar();
	//-->
      </script>

      <br /><br />

      <!-- Logo section -->
      <script type="text/javascript">
	<!--
	// Get the logo section from a separate file.
	DL.createLogoSection();
	//-->
      </script>

    </div> <!-- class: additionalinformation -->

  </div> <!-- class: overall_optionset -->

</body>
</html>
