<!--
 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

      http://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.
-->
<h2>Apache Commons Project Distributions</h2>

<p>
    The most recent source and binary releases for the Apache Commons project are available from this
    directory listing. For older releases, please use the
    <a href="https://archive.apache.org/dist/commons/">archives</a>.
</p>

<h2>Important Notices</h2>

<ul>
    <li><a href="#mirrors">Download from your nearest mirror site!</a></li>
    <li><a href="#sig">PGP/GPG Signatures</a></li>
</ul>

