<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<!--
Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved.
-->
<html>
   <head>
      <title>Installing and configuring PHP, Apache, and MySQL for PHP development in Windows</title>
     <meta name="KEYWORDS" content="NETBEANS, PHP, GUIDE, USER, DOCUMENTATION, XAMPP, MYSQL, APACHE">
      <meta name="DESCRIPTION" content="This document describes how to install and configure PHP, Apache, and MySQL for PHP development in the NetBeans IDE under Windows" >
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
      <link rel="stylesheet" type="text/css" href="../../../netbeans.css" media="screen"></head>
   <body>
<h1>Configuring PHP Development Environment in Windows</h1>
<p>This tutorial shows you two ways of configuring your PHP development environment on the Windows operating system. The first and most convenient way is to install and configure an AMP (<strong>A</strong>pache, <strong>M</strong>ySQL, <strong>P</strong>HP) package. This tutorial shows you how to install the XAMPP package. The second way is to install and configure each component separately.</p>
<!--
<div>
  <p>  -->
<!--    <!-- #BeginDate format:Am1-->
<!-- July 29, 2008 #EndDate -->
<!-- </p>
</div> -->
<p><strong>Contents</strong></p>
<img  src="../../../images_www/articles/73/netbeans-stamp-80-74-73.png" class="stamp" alt="Content on this page applies to NetBeans IDE 7.2, 7.3, 7.4 and 8.0" title="Content on this page applies to the NetBeans IDE 7.2, 7.3, 7.4 and 8.0" >
<ul>
<!--<li><a href="#requiredSoftware">Required Software</a></li> -->
<li><a href="#XAMPP">Using an AMP Package</a>
  <ul>
<li><a href="#installConfigureXAMPP">Installing and Configuring the XAMPP Package</a></li>
<li><a href="#checkXAMPPInstallation">Checking XAMPP Installation</a></li>
<li><a href="#installAndEnableXDebug">Installing and Enabling the XDebug Debugger</a></li>
</ul>
</li>
<li><a href="#installComponentsSeparately">Installing the Components Separately</a>
  <ul>
<li><a href="#installApacheComponent">Apache HTTP Server</a></li>
<li><a href="#installPHPEngine">PHP Engine</a></li> 
<li><a href="#installMySQL">MySQL Database Server</a></li>
<li><a href="#installXDebug">XDebug</a></li>
<li><a href="#settingUpEnvironment">Setting Up the Environment</a></li> 
</ul></li></ul>
<p><b>To follow this tutorial, you need the following software and resources.</b></p>

  <table>
    <tbody>
      <tr>
        <th class="tblheader" scope="col">Software or Resource</th>
        <th class="tblheader" scope="col">Version Required</th>
      </tr>
      <tr>
        <td class="tbltd1"><a target="_blank" href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td>
        <td class="tbltd1">PHP download bundle</td>
      </tr>
      <tr>
        <td class="tbltd1">A PHP engine</td>
        <td class="tbltd1">Version 5. Included in <a target="_blank" href="http://www.apachefriends.org/en/xampp-windows.html">XAMPP-Windows</a>. 
        </tr>
      <tr>
        <td class="tbltd1">A web server</td>
        <td><a target="_blank" href="http://httpd.apache.org/download.cgi">Apache HTTP Server 2.2</a> is recommended.<br>
          Included in XAMPP Windows.</td>
      </tr>
      <tr>
        <td class="tbltd1">A database server</td>
        <td><a target="_blank" href="http://dev.mysql.com/downloads/mysql/5.1.html">MySQL Server 5.0</a> is recommended.<br>
          Included in XAMPP Windows.</td>
      </tr>
      <tr>
        <td class="tbltd1">A PHP debugger (optional)</td>
        <td><a target="_blank" href="http://www.xdebug.org">XDebug 2.0 or later.</a><br/></td>
      </tr>
    </tbody>
  </table>
<p class="notes">Typically, development and debugging is performed on a local
  web server, while the production environment is located on a remote web server.
  Setting up a remote web server is described in <a href="./remote-hosting-and-ftp-account.html"> Deploying a PHP Application on a Remote Web Server Using the NetBeans 
  IDE</a>. This tutorial has you set up a local web server. PHP support
  can be added to
  a number of local web servers (IIS, Xitami, and so on), but most commonly <a target="_blank" href="http://httpd.apache.org/download.cgi">Apache HTTP Server</a> is used.
  Apache HTTP server is included in the XAMPP AMP package used in this tutorial.
  For information on installing and configuring Apache HTTP server standalone,
  click <a target="_blank" href="http://httpd.apache.org/docs/2.2/install.html">here</a>. </p>
<h2><a name="requiredSoftware"></a>Required Software</h2>
<p>To create, run, and debug your PHP projects you need the following software:</p>
<ul>
  <li>The NetBeans IDE for PHP.  Downloads are available <a target="_blank" href="https://netbeans.org/downloads/index.html">here</a>. </li>
  <li>A web server. Typically development and debugging is performed on a local web server, while the production environment is located on a remote web server. The current version enables using a local server. Using a remote server with FTP access will be supported in future versions. PHP support can be added to a number of web servers (IIS, Xitami, and so on), but most commonly <a target="_blank" href="http://httpd.apache.org/download.cgi">Apache HTTP Server</a> is used. Click <a target="_blank" href="http://httpd.apache.org/docs/2.2/install.html">here</a> for information on how to install and configure Apache 2.2. <a target="_blank" href="http://httpd.apache.org/docs/2.2/install.html"></a></li>
</ul>
<ul>
  <li>The PHP engine. The supported version is PHP5. Downloads are available <a target="_blank" href="http://www.php.net/downloads.php">here</a>. </li>
  <li>The PHP debugger. The NetBeans IDE for PHP allows you to use <a target="_blank" href="http://www.xdebug.org">XDebug</a>, but using a debugger is optional. The recommended version is XDebug 2.0 or higher as it is compatible with PHP5. </li>
  <li>A database server. You can use various database servers while one of the most popular ones is the MySQL server. Downloads are available <a target="_blank" href="http://dev.mysql.com/downloads/mysql/5.1.html">here</a>. <br>
      <strong>Note:</strong> The recommended version of the product is MySQL Server 5.0. The provided documents describe the work with this version.</li>
</ul>
<p>After the installation, you need to set up the environment  that all the software components work properly with each other. </p>
<p>You can use a <a href="#XAMPP"> Package</a>, that contains the required software, or <a href="#installComponentsSeparately">install each component separately</a>. </p>
<h2><a name="XAMPP" id="XAMPP"></a>Using an AMP Package</h2>
<p>To have all the configuration settings for the PHP engine, the Apache HTTP Server, and the MySQL database server  specified automatically, use an AMP package. This tutorial gives instructions only for the <a target="_blank" href="http://www.apachefriends.org/en/xampp-windows.html">XAMPP-Windows</a> package. For help with the WAMP package, please see the <a target="_blank" href="http://wiki.netbeans.org/HowToConfigureXDebug">NetBeans XDebug Wiki</a>.</p>
<h3><a name="installConfigureXAMPP"></a>Installing and Configuring the XAMPP Package</h3>
<p>The section describes how to download, install, and configure the XAMPP package. </p>
<p class="alert"><strong>Warning:</strong> Do NOT use XAMPP 1.7.0. There are significant problems with XDebug in this version. Use version 1.7.1 or later, where these problems are fixed.</p>
<p class="notes"><strong>Note: </strong>Starting with XAMPP 1.7.2, XAMPP comes with PHP 5.3, not PHP 5.2.x. NetBeans IDE for PHP version 6.7.x does not support the new PHP 5.3 functions. NetBeans IDE for PHP 6.8, currently available as a development build, fully supports PHP 5.3. Also note that Xdebug installation differs between PHP 5.2.x and PHP 5.3.</p>
<ol>
  <li>Download the  <a target="_blank" href="http://www.apachefriends.org/en/xampp-windows.html">XAMPP</a> installer package. (XAMPP Lite does not include  XDebug.)</li>
  <li>When the download is completed, run the <tt> .exe </tt>file. 
    <p class="alert">On Microsoft Vista, the User Access Control feature blocks the PHP installer from updating the Apache httpd configuration. Disable UAC while you are installing XAMPP. See <a target="_blank" href="http://support.microsoft.com/kb/922708">Microsoft support</a> for more information.<br>
    </p>
  </li>
  <li>You are given the option to install the Apache server and the MySQL database server as services. If you install the Apache Server and MySQL as services, you will not have to start them manually through the XAMP Control Panel.  Note that you have the option to install or uninstall these services in the <a href="#xamppConstolPanel">XAMPP Control Panel</a>.</li>
  <li>If you are using the self-extracting archive, after the archive is extracted, run the file <tt>setup-xampp.bat</tt> to configure the components of the package. (The XAMPP installer runs this file automatically.)</li>
  <li><a name="xamppConstolPanel" id="xamppConstolPanel"></a>After configuration, open the XAMP Control Panel. (You can open it manually by running the file <tt>XAMPP_HOME/xampp-control.exe</tt>  or from the Xampp Control Panel icon that is automatically placed on your desktop.) When you open the XAMPP Control Panel,
    note that the modules that are installed as services are already running.
    <p class="alert"><b>Warning: </b>On Windows Vista sometimes <tt>xampp-control.exe</tt> will not run. You can run <tt>xampp-start.exe</tt> instead.</p>
    <p class="alert"><b>Warning: </b>The <tt>winmysqladmin.exe file</tt>, which is launched by the Admin button for MySQL, does not work. A cascade of error messages appears, which can only be stopped by manually terminating the <tt>winmysqladmin</tt> process. You cannot launch <tt>winmysqladmin.exe</tt> from the command line, either. See <a target="_blank" href="http://bugs.xampp.org/view.php?id=71">http://bugs.xampp.org/view.php?id=71</a>.</p>
  <img src="../../../images_www/articles/72/php/configure-php-environment-windows/xampp-control-panel.png" alt="XAMPP Control Panel" class="margin-around" width="454" height="361"> </li>
  <li>The Svc checkboxes indicate that a module is installed as a Windows service and will start automatically on system startup. You can install or uninstall Windows services by selecting or unselecting the Svc checkbox. Uninstalling a Windows service does not uninstall the module, but it does require you to start the module manually. The XAMPP control panel includes buttons for stopping and starting modules and opening their administration consoles.<br>
  </li>
  </ol>
<h3><a name="checkXAMPPInstallation"></a>Checking XAMPP Installation </h3>
<ol>
<li>Run your browser and enter the following URL: <tt>http://localhost</tt>. The XAMPP welcome page opens:<br>
<img src="../../../images_www/articles/72/php/configure-php-environment-windows/xampp-welcome-page.png" alt="XAMPP welcome page indicates that Apache is running" class="margin-around" border="1">
</li>
<li>To ensure that the Apache and MySQL servers have been installed as system services, restart your operating system, run the browser, and enter the <tt>http://localhost</tt> URL again. The XAMPP welcome page opens. Note that the XAMPP welcome page includes a menu in the left margin through which you can check the status of XAMPP components and run <tt>phpinfo()</tt>, among other useful features. <tt>phpinfo()</tt> returns a screen with configuration information about your XAMPP components.
<br><img src="../../../images_www/articles/72/php/configure-php-environment-windows/xampp-phpinfo.png" alt="Configuration information table returned by phpinfo()" class="margin-around"/></li>
</ol>
<h3><a name="installAndEnableXDebug"></a>Installing and Enabling the XDebug Debugger</h3>
<p>You need to configure your PHP stack to use XDebug. The process differs if you are using <a href="#xdebug-xampp-171">XAMPP 1.7.1</a>, which bundles PHP 5.2.6, or <a href="#xdebug-xampp-172">XAMPP 1.7.2</a>, which bundles PHP 5.3.</p>
<p class="alert">Many users have experienced difficulties in getting XDebug to work on their systems. Please see <a target="_blank" href="http://wiki.netbeans.org/HowToConfigureXDebug">our wiki</a> and the <a target="_blank" href="http://forums.netbeans.org/viewforum.php?f=13&sid=5b63e6774fe7859b5edd35b1192d8efd">NetBeans PHP Editor Users' Forum</a> for assistance.</p>

<div class="indent">
    <h4 id="xdebug-xampp-171">XDebug on XAMPP 1.7.1 (PHP 5.2)</h4>
<p>You must download XDebug, place the .dll file in your php extensions directory, and configure php.ini to find and use this file.</p>
<ol>
<li>Download the latest <em>thread-safe</em> <a target="_blank" href="http://www.xdebug.org/download.php">XDebug</a> compatible with your version of PHP. The download links are listed under Releases. Copy the <tt>.dll</tt> file to your <tt>XAMP_HOME/php/ext</tt> directory.


  (<tt>XAMPP_HOME</tt> refers to your XAMPP or XAMPP Lite installation directory, such as <tt>C:\Program Files\xampp</tt> or <tt>C:\xampplite</tt>.)</li>
<li>Locate and open the active <tt>php.ini</tt> file for your XAMPP. This is located by default in the<tt> XAMPP_HOME/apache/bin</tt> directory. Confirm which <tt>php.ini</tt> file is active by running <tt>phpinfo()</tt> and searching for Loaded Configuration File.</li>
<li>Because Zend optimizer blocks XDebug, you need to disable Zend optimizer. In the active <tt>php.ini </tt>file,  locate the following lines and delete them or mark as comments (To be safe, search for and comment out all properties related to Zend):
  <pre class="examplecode">
[Zend]
;zend_extension_ts = "C:\Program Files\xampp\php\zendOptimizer\lib\ZendExtensionManager.dll"
;zend_extension_manager.optimizer_ts = "C:\Program Files\xampplite\php\zendOptimizer\lib\Optimizer"
;zend_optimizer.enable_loader = 0
;zend_optimizer.optimization_level=15
;zend_optimizer.license_path =
</pre>
</li>
<li>To attach<a name="attachXDebug" id="attachXDebug"></a> XDebug to the PHP engine, uncomment the following lines in the <tt>php.ini</tt> files (directly beneath the [Zend] section, add them if not there).
  Some additional notes have been added.
  <pre class="examplecode">[XDebug]<br>; Only Zend OR (!) XDebug
zend_extension_ts = &quot;./php/ext/php_xdebug&lt;-version-number&gt;.dll&quot;
; XAMPP and XAMPP Lite 1.7.0 and later come with a bundled xdebug at &lt;XAMPP_HOME&gt;/php/ext/php_xdebug.dll, without a version number.<br>xdebug.remote_enable=1<br>xdebug.remote_host=127.0.0.1<br>xdebug.remote_port=9000
; Port number must match debugger port number in NetBeans IDE Tools &gt; Options &gt; PHP<br>xdebug.remote_handler=dbgp<br>xdebug.profiler_enable=1<br>xdebug.profiler_output_dir=&quot;&lt;XAMPP_HOME&gt;\tmp&quot;<br>
  </pre>
  <p>Set the <tt>xdebug.remote_enable</tt> property to 1, not "true" or any other value.</p>
<p class="notes"><strong>Note:</strong> Make sure the paths you specify match the location of the corresponding files as determined during your installation.</p></li>
<li>Save <tt>php.ini</tt>.</li>
<li>Run the <a href="#xamppConstolPanel">XAMPP Control Panel Application</a> and restart the Apache server. </li>
</ol>
See <a target="_blank" href="http://wiki.netbeans.org/HowToConfigureXDebug">our wiki</a> and the <a target="_blank" href="http://www.xdebug.org/docs/install">XDebug documentation</a> for more information on how to configure XDebug.<br>
<h4 id="xdebug-xampp-172">Xdebug on XAMPP 1.7.2 (PHP 5.3)</h4>
<p>XAMPP 1.7.2 comes bundled with the appropriate Xdebug .dll file. You only have to configure <tt>php.ini</tt> to use it. Note that all Xdebug settings have text explaining them.</p>
<ol>
  <li>Locate and open <tt>XAMPP_HOME\php\php.ini</tt> for editing. This is the only <tt>php.ini</tt> file in XAMPP 1.7.2.</li>
  <li>Find and uncomment the line <tt>zend_extension =   "XAMPP_HOME\php\ext\php_xdebug.dll"</tt>.</li>
  <li>Find and uncomment the line <tt>xdebug.remote_host=localhost</tt>. Change the value of the setting from <tt>localhost</tt> to <tt>127.0.0.1</tt>.</li>
  <li>Find and uncomment the line <tt>xdebug.remote_enable = 0</tt>. Change  0 to 1.</li>
  <li>Find and uncomment the line <tt>xdebug.remote_handler = "dbgp"</tt>.</li>
  <li>Find and uncomment the line <tt>xdebug.remote_port = 9000</tt>.</li>
  <li>Save <tt>php.ini</tt>.</li>
  <li>Run the <a href="#xamppConstolPanel">XAMPP Control Panel Application</a> and restart the Apache server. </li>
  </ol>
<p>See <a target="_blank" href="http://wiki.netbeans.org/HowToConfigureXDebug">our wiki</a> and the <a target="_blank" href="http://www.xdebug.org/docs/install">XDebug documentation</a> for more information on how to configure XDebug.<br>
</p>
</div>
<h2><a name="installComponentsSeparately" id="installComponentsSeparately"></a>Installing the Components Separately </h2>
<div class="indent">
<h3><a name="installApacheComponent"></a>Apache HTTP Server</h3>
<ol>
  <li>Download the <a target="_blank" href="http://httpd.apache.org/download.cgi">Apache2 HTTP server</a>.</li>
  <li>Run the installation file <tt>.msi</tt>. The installation wizard starts. Follow the instructions.
  <p class="alert">On Microsoft Vista, do not install the Apache Server to the default location, which is in Program Files. All files in Program Files are write-protected.</p></li>
  <li>When the installation is completed, restart the Apache server. </li>
  <li>To check that the installation is successful, run the browser and enter the following URL:
    <pre class="examplecode">
  http://localhost/</pre> 
  The Apache welcome test page opens: <br>
  <img src="../../../images_www/articles/72/php/configure-php-environment-windows/install-apache-it-works-port80.png" alt="Apache web server test page indicates that Apache is running" class="margin-around"> </li>
</ol>
<h4>Troubleshooting</h4>
By default, the Apache server listens to port 80. This port can be already used by other services, for example Skype. To solve the issue, change the port which the server listens to: 
  <ol>
    <li>Open the Apache web server configuration file <tt>httpd.conf</tt>. By default the file is located in <tt>C:\Program Files\Apache Software Foundation\Apache&lt;version>\conf\</tt></li>
	<li>Locate the line <tt>Listen 80</tt> and change the port number, for example <tt>8080</tt>. Save the file.</li>
	<li>Restart the Apache web server.</li>
	<li>To check that the web server works, run the browser and enter the URL and specify the port number explicitly:
	<tt>http://localhost:8080</tt></li>
</ol>
  <p>You can also stop the processes that possibly listen to port 80. In the Task Manager, select the relevant file name and click End Process.  </p>
  <p>Find more information on installing and configuring the server <a target="_blank" href="http://httpd.apache.org/docs/2.2/install.html">here</a>. </p>
  <h3><a name="installPHPEngine"></a>PHP Engine</h3>
<ol>
  <li>Download the <a target="_blank" href="http://windows.php.net/download/">Windows binary installer</a> for the PHP5 version of your choice.
      <p class="alert"><strong>Important: </strong>If there is no installer available for the version of PHP you want to install, you have to install it manually from the .zip file. See <a href="http://php.net/manual/en/install.windows.manual.php" target="_blank">Manual Instruction Steps</a> in the php.net documentation.</p></li>
  <li>When the download is complete, run the <tt>.msi</tt> installation file. The installation wizard starts. </li>
  <li>On the Apache Configuration Directory panel, specify the directory where the <tt>httpd.conf</tt> file is located, the default setting is <tt>C:\Program Files\Apache Software Foundation\Apache&lt;version>\conf\</tt>. The PHP  processing will be enabled automatically.</li>
  <li>If you want to use the MySQL database server, choose the Complete installation option or select the MySQL and MySQLi items in the Extensions list. </li>
  <li>After the installation is completed, restart the Apache server. </li>
  <li>To check that the PHP engine has been installed successfully and PHP processing has been enabled in the Apache configuration:
    <ul>
  <li>Open Notepad or another text editor. Create a file and type the following text:
  <pre class="examplecode">&lt;?php 
     echo &quot;PHP has been installed successfully!&quot;;
?&gt;</pre>  </li>
  <li>Save the file in the htdocs folder as <code>test.php</code>. The default path is <tt>C:\Program Files\Apache Software Foundation\Apache&lt;version>\htdocs\test.php</tt></li>
  <li>Run the browser and enter the following URL: <tt>http://localhost:&lt;port>/test.php</tt>. The following page opens:<br>
  <img src="../../../images_www/articles/72/php/configure-php-environment-windows/install-php-test.png" alt="PHP test page indicates that the PHP engine is enabled" class="margin-around">
   </li>
  </ul>
  </li>
</ol>
<h4>Troubleshooting</h4>
If the page does not open:
<ol>
  <li>Restart the Apache server.</li>
  <li>Check that the Apache server configuration file httpd.conf contains the following lines:
     <pre class="examplecode">
  AddType Application/x-httpd-php .php 
  LoadModule php5_module &quot;c:/php/sapi/php5apache2_2.dll&quot;</pre>
  </li>
  <li>If the lines are missing, add them, save <tt>httpd.conf</tt>, and restart Apache.</li>
  <li>Refresh the http://localhost:&lt;port&gt;/test.php page.   </li>
</ol>
<h3><a name="installMySQL"></a>MySQL Database Server</h3>
<p>Find detailed information on <a href="../ide/install-and-configure-mysql-server.html">installing and configuring the MySQL</a> database server. </p>
<h3><a name="installXDebug"></a>XDebug  </h3>
<ol>
<li>Download <a target="_blank" href="http://www.xdebug.org">XDebug</a>.</li>
<li>Install XDebug into the <tt>php/</tt> folder. You will need the path to it to <a href="#settingUpEnvironment">configure your environment</a>.</li>
</ol>

<h3><a name="settingUpEnvironment"></a>Setting Up  the Environment  </h3>
<ol>
  <li>If your installation follows the default settings,  PHP processing will be enabled automatically. </li>
  <li>To attach<a name="attachXDebug" id="attachXDebug"></a> XDebug to the PHP engine, locate the <tt>php.ini</tt> file and add the following lines to it:
  <p>For a <strong>thread-safe</strong> PHP 5.2 engine:  
  <pre class="examplecode">zend_extension_ts=&quot;&lt;path to the php folder&gt;/php_xdebug-&lt;version-number&gt;.dll&quot;
xdebug.remote_enable=1</pre>
<p>For a <strong>non-thread-safe</strong> PHP 5.2 engine: </p>
<pre class="examplecode">zend_extension_nts="&lt;path to the php folder&gt;/php_xdebug-&lt;version-number&gt;.dll"
xdebug.remote_enable=1</pre>
<p>For <b>any</b> PHP 5.3 engine:</p>
<pre class="examplecode">zend_extension="&lt;path to the php folder&gt;/php_xdebug-&lt;version-number&gt;.dll"
xdebug.remote_enable=1</pre>

  <p>Some users also find that they need to include the following lines, although other users do not:</p>
<pre>xdebug.remote_host=127.0.0.1<br>xdebug.remote_port=9000
; Port number must match debugger port number in NetBeans IDE Tools &gt; Options &gt; PHP<br>xdebug.remote_handler=dbgp<br></pre>
  <p>Click <a target="_blank" href="http://www.xdebug.org/docs/install">here</a> for more information on how to configure XDebug.</p>
  <p class="notes"><strong>Note:</strong> Make sure the paths you specify match the names and locations of the corresponding files as determined during your installation.</p></li>
  <li>To be sure that previously installed PHP engine supports using the MySQL database server:
    <ol type="a">
      <li type="a">Click Start &gt; Control Panel.</li>
      <li type="a">On the Control Panel, choose Add or Remove Programs. </li>
      <li type="a">On the Add or Remove Programs panel, select the PHP &lt;version number&gt; area and click Change. The PHP Setup Wizard starts. Click Next.</li>
      <li type="a">On the Change, repair or remove installation panel, choose Change and click Next. </li>
      <li>On the Web Server Setup panel, choose the version of the Apache server - in our example it is  Apache 2.2.x Module. Click Next.</li>
      <li>On the Apache Configuration Directory panel, specify the directory where the Apache configuration file <tt>httpd.conf</tt> is located. Click Next.</li>
      <li>On the Choose Items to Install panel, expand the Extensions node and choose the MySQL and MySQLi items. Click Next.</li>
      <li>On the Ready to change PHP &lt;version number&gt; panel, click Change.</li>
      <li>On the Completed the PHP &lt;version number&gt; Setup Wizard panel, click Finish.</li>
    </ol>
    <br></li>
  </ol>
  </div>
  <div class="feedback-box" ><a href="/about/contact_form.html?to=3&amp;subject=Feedback:%20Configuring%20PHP%20on%20Windows">Send Feedback on This Tutorial</a></div>
<br style="clear:both;" />

<p>To send comments and suggestions, get support, and keep informed on the latest
  developments on the NetBeans IDE PHP development features, <a href="../../../community/lists/top.html">join
  the users@php.netbeans.org mailing list</a>.</p>
<a href="../../trails/php.html">Back to the PHP Learning Trail</a>
</body>
</html>
