<!doctype html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta http-equiv="content-type" content="text/html; charset=iso-8859-1">
<meta http-equiv="content-style-type" content="text/css">
<link rel="stylesheet" type="text/css" href="style.css">
<title>ProGuard License</title>
</head>
<body>

<script type="text/javascript" language="JavaScript">
<!--
if (window.self==window.top)
  document.write('<a class="largebutton" target="_top" href="index.html#license.html">ProGuard index</a> <a class="largebutton" target="_top" href="http://www.guardsquare.com/dexguard">DexGuard</a> <a class="largebutton" target="_top" href="http://www.guardsquare.com/">GuardSquare</a> <a class="largebutton" target="other" href="http://sourceforge.net/projects/proguard/">Sourceforge</a>')
//-->
</script>
<noscript>
<a class="largebutton" target="_top"  href="index.html#license.html">ProGuard index</a>
<a class="largebutton" target="_top"  href="http://www.guardsquare.com/dexguard">DexGuard</a>
<a class="largebutton" target="_top"  href="http://www.guardsquare.com/">GuardSquare</a>
<a class="largebutton" target="other" href="http://sourceforge.net/projects/proguard/">Sourceforge</a>
</noscript>

<h2>License</h2>

<b>ProGuard</b> is free. You can use it freely for processing your
applications, commercial or not. Your code obviously remains yours after
having been processed, and its license can remain unchanged.
<p>

The <b>ProGuard code</b> itself is copyrighted, but its distribution license
provides you with some rights for modifying and redistributing its code and
its documentation. More specifically, ProGuard is distributed under the terms
of the <a href="GPL.html">GNU General Public License</a> (GPL), version 2, as
published by the <a href="http://www.fsf.org/" target="other">Free Software
Foundation</a> (FSF). In short, this means that you may freely redistribute
the program, modified or as is, on the condition that you make the complete
source code available as well. If you develop a program that is linked with
ProGuard, the program as a whole has to be distributed at no charge under the
GPL. I am granting a <a href="GPL_exception.html">special exception</a> to the
latter clause (in wording suggested by the
<a href="http://www.gnu.org/copyleft/gpl-faq.html#GPLIncompatibleLibs"
target="other">FSF</a>), for combinations with the following stand-alone
applications: Gradle, Apache Ant, Apache Maven, the Google Android SDK, the
Eclipse ProGuardDT GUI, the EclipseME JME IDE, the Oracle NetBeans Java IDE,
the Oracle JME Wireless Toolkit, and the Simple Build Tool for Scala.

<p>
The <b>ProGuard user documentation</b> is copyrighted as well. It may only be
redistributed without changes, along with the unmodified version of the code.

<hr />
<address>
Copyright &copy; 2002-2017
<a target="other" href="http://www.lafortune.eu/">Eric Lafortune</a> @ <a target="top" href="http://www.guardsquare.com/">GuardSquare</a>.
</address>
</body>
</html>
