<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
    <head>
        <title>NetBeans IDE Sample Applications</title>
        <meta name="description" content="A list of example projects for Java EE, Java SE, Ruby on Rails, PHP, and other technologies. All sample applications are created with NetBeans IDE.">
        <meta http-equiv="Content-Type" content="text/html; charset=utf8">
        <meta http-equiv="Content-Style-Type" content="text/css" />
        <link rel="stylesheet" type="text/css" href="https://netbeans.org/netbeans.css" media="screen">
        <link rel="stylesheet" type="text/css" href="https://netbeans.org/kb/netbeans_sample.css" media="screen">
        <script src="https://netbeans.org/images_www/js/listCollapse.js" type="text/javascript" language="javascript1.2"></script>
<style type="text/css">
ul { list-style-type:none }
</style>
    </head>
    <body>

    <h1>Get Inspired. Get Started.</h1>

     <div style="float:right;width:330px;padding:0 0 20px 30px">
      <div class="trail-box">
         <div class="trail-box-header">
            <img src="../../images_www/v6/trails/trails-box-tr.png" width="7" height="21" class="right">
            <img src="../../images_www/v6/trails/trails-box-tl.png" width="7" height="21" class="left">
            <strong>How to find samples in the IDE:</strong>         </div>
        <div class="trail-box-content">
          <img src="../../images_www/sample-catalog/samples-open.png" alt="Screenshot of the New Project wizard" /><br /><br />
          In the IDE, choose File &gt; New Project and select the Samples category as the project type/
          </p>
         </div>
         <div class="trail-box-bottom">
            <img src="../../images_www/v6/trails/trails-box-br.png" width="7" height="6" class="right">
            <img src="../../images_www/v6/trails/trails-box-bl.png" width="7" height="6" class="left">
         </div>
       </div>
      </div>

        <p>NetBeans IDE not only provides great productivity tools, but also includes <em>sample applications</em> and <em>tutorial solutions</em>          that show you complex technologies at work. These samples are provided as ready-to-use NetBeans
          IDE projects and each comes with an informative readme file so you can get started quickly &mdash;
            check them out!</p>

        <h2>Where to Find Samples and Solutions </h2>

        <ul>
          <li><strong>Sample Applications</strong>. Ready-to-use sample applications are bundled with the NetBeans IDE. Create a new project  (File &gt; New Project) and select the Samples category.</li>
          <li><strong>Tutorial Solutions</strong>. At the end of many <a href="../index.html" target="_blank">NetBeans IDE tutorials</a>, you usually create an application. Download a complete solution to the tutorial you are reading! Expand the tree below or go to <a href="http://netbeans.org/projects/samples/downloads/" target="_blank">NetBeans IDE Samples Downloads</a>.  </li>
        </ul>

        <h2>Download Tutorial Solutions</h2>

        <p>The samples for the <em>current version</em> of the IDE are listed under the main <strong>Samples</strong> node </p>


    <!-- Browsing Kenai's project downloads at https://netbeans.org/projects/samples... Begin. -->

<ul  id="collapsableList">
<li><b>NetBeans IDE 6.5</b>
<ul  id="collapsableList">
<li><b>Java</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: CarPreview</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.5/Java/CarPreview.zip">[Download]</a><br>
    <blockquote>Description:                                            To do <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Customer Book - test</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.5/Java/CustomerBook.zip">[Download]</a><br>
    <blockquote>Description:                                            Test sample <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: TwitterSwingClient</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.5/Java/TwitterSwingClient.zip">[Download]</a><br>
    <blockquote>Description:                                            This is a simple, graphical, REST-based client that displays Twitter public timeline messages. <br>                    Tags:                                           swing                                           twitter                                           client                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
</ul>
</li>
<li><b>NetBeans IDE 6.7</b>
<ul  id="collapsableList">
<li><b>Java Web</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using Java Persistence in a Java EE 5 Web Application</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.7/Java Web/CustomerBook.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the solution to the <a href="http://netbeans.org/kb/67/web/customer-book.html">Using Java Persistence in a Java EE 5 Web Application</a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           java                                           web                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using Hibernate in a Java EE 5 Web Application </b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.7/Java Web/DVDStore.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the solution to the <a href="http://netbeans.org/kb/67/web/hibernate-webapp.html">Using Hibernate in a Java EE 5 Web Application </a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           java                                           web                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: NewsApp solution zip archive</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.7/Java Web/NewsApp.zip">[Download]</a><br>
    <blockquote>Description:                                            NewsApp Solution project for NetBeans tutorial to create an EJB with a Message-Driven Bean and Session Bean using NetBeans IDE 6.7 <br>                    Tags:                                           netbeans                                           solution                                           javaee                                           web                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>JavaEE</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: ZooApp solution zip archive</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.7/JavaEE/ZooApp.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the solution to the Java Persistence in the Java EE 5 Platform tutorial that demonstrates using Java Persistence. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
</ul>
</li>
<li><b>NetBeans IDE 6.8</b>
<ul  id="collapsableList">
<li><b>JavaEE</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating an Application Client</b> <a href="https://netbeans.org/projects/samples/downloads/download/NetBeans IDE 6.8/JavaEE/entappclient.zip">[Download]</a><br>
    <blockquote>Description:                                            An archive of the solution to the <a href="http://netbeans.org/kb/docs/javaee/entappclient.html">Creating an Application Client</a> tutorial for users of GlassFish 3.0. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
</ul>
</li>
<li><b>Samples</b>
<ul  id="collapsableList">
<li><b>CPlusPlus</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: JNIDemo</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/CPlusPlus/JNIDemo.zip">[Download]</a><br>
    <blockquote>Description:                                            Sample code shows Java Native Interface (JNI) application for tutorial at http://netbeans.org/kb/docs/cnd/beginning-jni-linux.html <br>                    Tags:                                           netbeans                                           jni                                           linux                                           c                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>Java</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Enabling Java Web Start</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/ConverterPrj.zip">[Download]</a><br>
    <blockquote>Description:                                            An application which converts measurements between metric and U.S. units. Used as an example in the <a href="http://netbeans.org/kb/docs/java/javase-jws.html">Enabling Java Web Start</a> tutorial. <br>                    Tags:                                           java                                           web                                           start                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using Hibernate in a Java Swing Application</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Ant.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive containing the solution to the <a href="http://netbeans.org/kb/docs/java/hibernate-java-se.html">Using Hibernate in a Java Swing Application</a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           hibernate                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating a Maven Swing Application Using Hibernate</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/DVDStoreAdmin-Maven.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive containing the solution to the <a href="http://netbeans.org/kb/docs/java/maven-hib-java-se.html">Creating a Maven Swing Application Using Hibernate</a> tutorial. <br>                    Tags:                                           netbeans                                           maven                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Deadlock Detection and Debugging Multithreaded Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/debugging-samples.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive containing sample projects used in the <a href="http://netbeans.org/kb/docs/java/debug-multithreaded.html">Deadlock Detection and Debugging Multithreaded Applications</a> tutorial. <br>                    Tags:                                           netbeans                                           debugging                                           sample                                           solution                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Deployment tutorial for JavaSE</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/DeploymentTutorial.zip">[Download]</a><br>
    <blockquote>Description:                                            Source files for the Java SE Deployment tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Designing an Advanced Java Form Using the GridBag Customizer</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/gbcustomizer-advanced-tutorial.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive with the demo project used in the <a href="https://netbeans.org/kb/docs/java/gbcustomizer-advanced.html">Designing an Advanced Java Form Using the GridBag Customizer</a> tutorial. <br>                    Tags:                                           java                                           netbeans                                           gridbag                                           layout                                           customizer                                           gui                                           builder                                           advanced                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Exploring GridBag Customizer Basic Features</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/gbcustomizer-basic-tutorial.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive with the GridBagCustomizerBasicTutorial demo project containing the initial and target tutorial layouts. <br>                    Tags:                                           java                                           netbeans                                           gridbag                                           layout                                           customizer                                           gui                                           builder                                           basic                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Code Formatting Features in NetBeans IDE</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/Formatting.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive containing a demo project for the <a href="http://netbeans.org/kb/docs/java/editor-formatting-screencast.html">Code Formatting Features in NetBeans IDE</a> screencast. <br>                    Tags:                                           java                                           editor                                           formatting                                           indentation                                           braces                                           import                                           project-specific                                           netbeans                                           ide                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Gap Editing Support in the NetBeans GUI Builder</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/GapSupport.zip">[Download]</a><br>
    <blockquote>Description:                                            An archive with the initial and target layouts used in the <a href="http://netbeans.org/kb/docs/java/gui-gaps.html">Gap Editing Support in the NetBeans GUI Builder</a> tutorial. <br>                    Tags:                                           gui                                           builder                                           component                                           gap                                           edit                                           layout                                           space                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Hello 3D World zip archive</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java/Hello3DWorld.zip">[Download]</a><br>
    <blockquote>Description:                                            How to get started with 3-D Java games using the jMonkeyEngine, and how to package a Java project (incl. native libraries) into one JAR. <br>                    Tags:                                           netbeans                                           sample                                           project                                           3-d                                           java                                           jmonkeyengine                                           jar                                           ant                                           one-jar                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>Java Web</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Generating a JSF 1.2 CRUD Application from a Database</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/ConsultingAgency.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution project for the tutorial <a href="http://netbeans.org/kb/docs/web/jsf-jpa-crud-wizard.html">Generating a JSF 1.2 CRUD Application from a Database</a>. <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: DojoTreeSample</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/DojoTreeSample.zip">[Download]</a><br>
    <blockquote>Description:                                            Sample used for Dojo tutorial for NetBeans IDE 7.3 <br>                    Tags:                                           netbeans                                           web                                           7.3                                           dojo                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to the Google Web Toolkit tutorial</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/HelloGWT.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution project for the <a href="http://www.netbeans.org/kb/docs/web/quickstart-webapps-gwt.html">Introduction to the Google Web Toolkit tutorial</a> <br>                    Tags:                                           gwt                                           google                                           web                                           toolkit                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to the Spring Framework</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/HelloSpring69.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution project for the <a href="http://netbeans.org/kb/docs/web/quickstart-webapps-spring.html">Introduction to the Spring Framework</a> tutorial (version 6.9) <br>                    Tags:                                           spring                                           web                                           mvc                                           framework                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to the Spring Framework</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/HelloSpring.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution project for the <a href="http://netbeans.org/kb/68/web/quickstart-webapps-spring.html">Introduction to the Spring Framework</a> tutorial (versions 6.7, 6.8) <br>                    Tags:                                           spring                                           mvc                                           framework                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to Developing Web Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/HelloWeb.zip">[Download]</a><br>
    <blockquote>Description:                                            EE 5 version of the application created in the <a href="http://netbeans.org/kb/docs/web/quickstart-webapps.html">Introduction to Developing Web Applications</a> tutorial <br>                    Tags:                                           web                                           ee5                                           introduction                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to Developing Web Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/HelloWebEE6.zip">[Download]</a><br>
    <blockquote>Description:                                            EE6 version of the application created in the <a href="http://netbeans.org/kb/docs/web/quickstart-webapps.html">Introduction to Developing Web Applications</a> tutorial. Works only on GlassFish v3! <br>                    Tags:                                           ee6                                           introduction                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating a Simple Web Application Using a MySQL Database</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/IFPWAFCAD.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution project for the <a href="http://netbeans.org/kb/docs/web/mysql-webapp.html">Creating a Simple Web Application Using a MySQL Database</a> tutorial <br>                    Tags:                                           mysql                                           web                                           application                                           webapp                                           glassfish                                           data                                           source                                           connection                                           pool                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to Ajax</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Java Web/MyAjaxApp.zip">[Download]</a><br>
    <blockquote>Description:                                            The solution project for the <a href="http://netbeans.org/kb/docs/web/ajax-quickstart.html">Introduction to Ajax</a> tutorial <br>                    Tags:                                           ajax                                           asynchronous                                           javascript                                           xml                                       </blockquote>
    <div class="clear"></div>  </li>
<li><b>Modifying JSP Pages in the Generated JSF 1.2 CRUD Application</b>
<p>Failed reading Kenai download directory of https://netbeans.org/http://netbeans.org/kb/docs/web/jsf-jpa-crud-code1.html</p><ul  id="collapsableList">
</ul>
</li>
</ul>
</li>
<li><b>JavaEE</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Generating a JavaServer Faces 2.0 CRUD Application from a Database</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ConsultingAgencyJSF20.zip">[Download]</a><br>
    <blockquote>Description:                                            The solution project for the <a href="http://netbeans.org/kb/docs/web/jsf20-crud.html">Generating a JavaServer Faces 2.0 CRUD Application from a Database</a> tutorial <br>                    Tags:                                           javaserver                                           faces                                           2.0                                           jsf                                           crud                                           eclipselink                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using Hibernate in a Web Application</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/DVDStoreEE6.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the Java EE 6 version of the solution to the <a href="http://netbeans.org/kb/docs/web/hibernate-webapp.html">Using Hibernate in a Web Application</a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                           hibernate                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating an Application Client</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/EntAppClientEE6.zip">[Download]</a><br>
    <blockquote>Description:                                            An zip archive of the solution to the <a href="http://netbeans.org/kb/docs/javaee/entappclient.html">Creating an Application Client</a> tutorial for users of GlassFish 3.1. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating an Enterprise Application Using Maven</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/MavenEnterpriseApp.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the Java EE 6 version of the solution to the <a href="http://netbeans.org/kb/docs/javaee/maven-entapp.html">Creating an Enterprise Application Using Maven</a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating an Enterprise Application with EJB 3.1</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/NewsAppEE6.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the Java EE 6 version of the solution to the <a href="http://netbeans.org/kb/docs/javaee/javaee-entapp-ejb.html">Creating an Enterprise Application with EJB 3.1</a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Getting Started with Java EE 5 Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/NewsApp.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution to the <a href="http://netbeans.org/kb/67/javaee/ejb30.html">Getting Started with Java EE 5 Applications</a> tutorial to create a 3.0 EJB with a MDB and Session Bean accessed via servlet. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Getting Started with Java EE 6 Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/SimpleEE6App72.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the solution to the <a href="http://netbeans.org/kb/docs/javaee/javaee-gettingstarted.html">Getting Started with Java EE 6 Applications</a> tutorial when using NetBeans IDE 7.2. <br>                    Tags:                                           netbeans                                           java                                           ee                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Getting Started with Java EE 6 Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/SimpleEE6App.zip">[Download]</a><br>
    <blockquote>Description:                                            A zip archive of the solution to the <a href="http://netbeans.org/kb/docs/javaee/javaee-gettingstarted.html">Getting Started with Java EE 6 Applications</a> tutorial. <br>                    Tags:                                           netbeans                                           solution                                           javaee                                       </blockquote>
    <div class="clear"></div>  </li>
<li><b>Consulting Agency JSF 1.2</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Consulting Agency - base 1</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/Consulting Agency JSF 1.2/base1.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution and sources for first part of the tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Consulting Agency - base 2</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/Consulting Agency JSF 1.2/base2.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution and sources for second part of the tutorial <br>                    Tags:                                           netbeans                                           solution                                           javaee                                           jsf                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Consulting Agency - base 3</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/Consulting Agency JSF 1.2/base3.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution and sources for second part of the tutorial <br>                    Tags:                                           netbeans                                           solution                                           javaee                                           jsf                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: mysql-zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/Consulting Agency JSF 1.2/mysql-consult.zip">[Download]</a><br>
    <blockquote>Description:                                            archive containing sql script for creating and populating the MySQL database for use in the Consulting Agency CRUD JSF 1.2 tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>ecommerce</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: NetBeans E-commerce Tutorial</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_complete.zip">[Download]</a><br>
    <blockquote>Description:                                            The completed project for the <a href="http://netbeans.org/kb/docs/javaee/ecommerce/intro.html">NetBeans E-commerce Tutorial</a> <br>                    Tags:                                           e-commerce                                           netbeans                                           tutorial                                           affablebean                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Preparing the Page Views and Controller Servlet</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot1.zip">[Download]</a><br>
    <blockquote>Description:                                            Placeholders created for all page views. See <a href="http://netbeans.org/kb/docs/javaee/ecommerce/page-views-controller.html">Preparing the Page Views and Controller Servlet</a> <br>                    Tags:                                           affablebean                                           snapshot                                           1                                           e-commerce                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Securing the Application</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot10.zip">[Download]</a><br>
    <blockquote>Description:                                            The project snapshot used in the eleventh unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/security.html">Securing the Application</a> <br>                    Tags:                                           e-commerce                                           netbeans                                           tutorial                                           affablebean                                           declarative                                           security                                           ssl                                           form-based                                           authentication                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Preparing the Page Views and Controller Servlet</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot2.zip">[Download]</a><br>
    <blockquote>Description:                                            The snapshot of the project after completing the fifth unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/page-views-controller.html">Preparing the Page Views and Controller Servlet</a> <br>                    Tags:                                           affablebean                                           snapshot                                           2                                           e-commerce                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Connecting the Application to the Database</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot3.zip">[Download]</a><br>
    <blockquote>Description:                                            The snapshot of the project after completing the sixth unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/connect-db.html">Connecting the Application to the Database</a> <br>                    Tags:                                           affablebean                                           snapshot                                           3                                           e-commerce                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Adding Entity Classes and Session Beans</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot4.zip">[Download]</a><br>
    <blockquote>Description:                                            The project snapshot after completing the seventh unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/entity-session.html">Adding Entity Classes and Session Beans</a> <br>                    Tags:                                           e-commerce                                           affablebean                                           entity                                           session                                           facade                                           ejb                                           jpa                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Managing Sessions</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot5.zip">[Download]</a><br>
    <blockquote>Description:                                            The project snapshot used with the eighth unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/manage-sessions.html">Managing Sessions</a> <br>                    Tags:                                           e-commerce                                           affablebean                                           session                                           cookies                                           url                                           rewriting                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Managing Sessions</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot6.zip">[Download]</a><br>
    <blockquote>Description:                                            The snapshot of the project after completing the eighth unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/manage-sessions.html">Managing Sessions</a> <br>                    Tags:                                           e-commerce                                           affablebean                                           session                                           cookies                                           url                                           rewriting                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Integrating Transactional Business Logic</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot7.zip">[Download]</a><br>
    <blockquote>Description:                                            The project snapshot used with the ninth unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/transaction.html">Integrating Transactional Business Logic</a> <br>                    Tags:                                           e-commerce                                           netbeans                                           tutorial                                           affablebean                                           transaction                                           acid                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Integrating Transactional Business Logic</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaEE/ecommerce/AffableBean_snapshot8.zip">[Download]</a><br>
    <blockquote>Description:                                            The project snapshot after completing the ninth unit, <a href="http://netbeans.org/kb/docs/javaee/ecommerce/transaction.html">Integrating Transactional Business Logic</a> <br>                    Tags:                                           e-commerce                                           netbeans                                           tutorial                                           affablebean                                           transaction                                           acid                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
</ul>
</li>
<li><b>JavaFX Composer</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Hello World for JavaFX Composer</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaFX Composer/HelloWorldApp.zip">[Download]</a><br>
    <blockquote>Description:                                            A Hello World application for the "Getting Started with JavaFX Composer" tutorial <br>                    Tags:                                           javafx                                           composer                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: RESTful Data Source</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaFX Composer/RestfulDataSource.zip">[Download]</a><br>
    <blockquote>Description:                                            This is a completed sample application from the Working With a RESTful WS Data Source In JavaFX Composer tutorial, including all UI components <br>                    Tags:                                           rest                                           javafx                                           composer                                       </blockquote>
    <div class="clear"></div>  </li>
<li><b>Database Client</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: A css stylesheet</b> <a href="https://netbeans.org">[Download]</a><br>
    <blockquote>Description:                                            A css stylesheet for the DB Client tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: DB client application</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaFX Composer/Database Client/DBclient.zip">[Download]</a><br>
    <blockquote>Description:                                            DB client application for the Database Client tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Image</b> <a href="https://netbeans.org">[Download]</a><br>
    <blockquote>Description:                                            An image for the DB project <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>fxd-tutorial</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using JavaFX Graphic Resources</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaFX Composer/fxd-tutorial/FxdSample.zip">[Download]</a><br>
    <blockquote>Description:                                            A complete project for the <a href="http://netbeans.org/kb/docs/javafx/fxd.html">Using JavaFX Graphic Resources</a> tutorial for JavaFX Composer. <br>                    Tags:                                           javafx                                           composer                                           production                                           suite                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Logo image</b> <a href="https://netbeans.org">[Download]</a><br>
    <blockquote>Description:                                            The image in the EPS format <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
</ul>
</li>
<li><b>JavaScript</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Connecting a Dojo Tree to an ArrayList using JSON</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaScript/DojoTreeSample.zip">[Download]</a><br>
    <blockquote>Description:                                            The sample project used in the <a href="http://netbeans.org/kb/docs/web/js-toolkits-dojo.html">Connecting a Dojo Tree to an ArrayList using JSON</a> tutorial <br>                    Tags:                                           dojo                                           javascript                                           toolkits                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to Ajax for Java Web Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaScript/MyAjaxApp.zip">[Download]</a><br>
    <blockquote>Description:                                            The solution project for the <a href="http://netbeans.org/kb/docs/web/ajax-quickstart.html">Introduction to Ajax for Java Web Applications</a> tutorial <br>                    Tags:                                           ajax                                           javascript                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using jQuery to Enhance the Appearance and Usability of a Web Page</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaScript/jQueryProjectFiles.zip">[Download]</a><br>
    <blockquote>Description:                                            The project files used with the <a href="http://netbeans.org/kb/docs/web/js-toolkits-jquery.html">Using jQuery to Enhance the Appearance and Usability of a Web Page</a> tutorial <br>                    Tags:                                           jquery                                           javascript                                           toolkits                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Using jQuery to Enhance the Appearance and Usability of a Web Page</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/JavaScript/pix.zip">[Download]</a><br>
    <blockquote>Description:                                            JPG images used in the <a href="http://netbeans.org/kb/docs/web/js-toolkits-jquery.html">Using jQuery to Enhance the Appearance and Usability of a Web Page</a> tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>Mobile</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: ContactBrowserExample</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/ContactBrowserExample.zip">[Download]</a><br>
    <blockquote>Description:                                            Shows how to create an SVG-based, touch screen enabled UI for Java ME devices. <br>                    Tags:                                           touch                                           enabled                                           svg                                           ui                                           jsr226                                           widgets                                           composer                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: FileBrowserExample</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/filebrowserexample.zip">[Download]</a><br>
    <blockquote>Description:                                            Shows how to use File Browser component in a mobile application for JSR-75 enabled devices. <br>                    Tags:                                           filebrowser                                           visual                                           mobile                                           designer                                           midp                                           components                                           jsr-75                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: LoginScreenExample</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/LoginScreenExample.zip">[Download]</a><br>
    <blockquote>Description:                                            Shows how to use the Login Screen component within a client application and how to connect it to server resources using authenticated access. <br>                    Tags:                                           loginscreen                                           visual                                           mobile                                           designer                                           midp                                           components                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: LoginScreenServletExample</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/LoginScreenServletExample.zip">[Download]</a><br>
    <blockquote>Description:                                            Web application required for the LoginScreenExample mobile application. <br>                    Tags:                                           servlet                                           loginscreen                                           web                                           application                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: MobileClientToWebApplicationSample</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/MobileClientToWebApplicationSample.zip">[Download]</a><br>
    <blockquote>Description:                                            Shows the resulting web and mobile client projects for the Mobile Client to Web Application Wizard: Creating a Client-Server Application tutorial. <br>                    Tags:                                           mobile                                           client                                           to                                           web                                           application                                           wizard                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: MobileGame-for-adding-game-logic.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/MobileGame-for-adding-game-logic.zip">[Download]</a><br>
    <blockquote>Description:                                            Contains a project with additional files required for the Adding the Game Logic section of the Creating a Mobile Game tutorial (http://netbeans.org/kb/docs/javame/mobilegame.html). <br>                    Tags:                                           game                                           logic                                           visualmidlet                                           palette                                           wizard                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: MobileGame-for-creating-game.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/MobileGame-for-creating-game.zip">[Download]</a><br>
    <blockquote>Description:                                            Contains a project with additional files required for creating a game in the Creating the Game section of the Creating a Mobile Game tutorial (http://netbeans.org/kb/docs/javame/mobilegame.html). <br>                    Tags:                                           jsr                                           178                                           svg                                           game                                           builder                                           sprite                                           tiledlayer                                           scene                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: MobileGame-for-multiple-players-ready.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/MobileGame-for-multiple-players-ready.zip">[Download]</a><br>
    <blockquote>Description:                                            Contains a resulting project in the Playing with Friends section of the Creating a Mobile Game tutorial (http://netbeans.org/kb/docs/javame/mobilegame.html). <br>                    Tags:                                           jsr                                           172                                           web                                           service                                           client                                           multiplayer                                           game                                           svg                                           ui                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: MobileGame-for-multiple-players.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/MobileGame-for-multiple-players.zip">[Download]</a><br>
    <blockquote>Description:                                            Contains projects required for creating a game for multiple players in the Playing with Friends section of the Creating a Mobile Game tutorial (http://netbeans.org/kb/docs/javame/mobilegame.html). <br>                    Tags:                                           jsr                                           172                                           web                                           service                                           client                                           multiplayer                                           game                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: MobileGame-game-created.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Mobile/MobileGame-game-created.zip">[Download]</a><br>
    <blockquote>Description:                                            Shows a resulting project in the Creating the Game section of the Creating a Mobile Game tutorial (http://netbeans.org/kb/docs/javame/mobilegame.html). <br>                    Tags:                                           jsr                                           178                                           svg                                           game                                           builder                                           sprite                                           tiledlayer                                           scene                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>PHP</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Introduction to Ajax for PHP Web Applications</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/PHP/MyAjaxApp.zip">[Download]</a><br>
    <blockquote>Description:                                            Solution project for the <a href="http://netbeans.org/kb/docs/php/ajax-quickstart.html">Introduction to Ajax for PHP Web Applications</a> tutorial <br>                    Tags:                                           php                                           ajax                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>Platform</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: Creating NetBeans Platform Applications from Maven Archetypes</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Platform/mavenPlatformApp.zip">[Download]</a><br>
    <blockquote>Description:                                            Archive of project sources for the tutorial <a href=http://platform.netbeans.org/tutorials/nbm-maven-commandline.html>Creating NetBeans Platform Applications from Maven Archetypes</a>. <br>                    Tags:                                           netbeans                                           platform                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
<li><b>Web Client</b>
<ul  id="collapsableList">
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: HTML5 Demo project resources</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Web Client/HTML5Demo-projectresources.zip">[Download]</a><br>
    <blockquote>Description:                                            project resources for Getting Started with HTML5 Applications tutorial <br>                    Tags:                                           netbeans                                           html5                                           web                                           client                                           javascript                                           css                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: HTML5DemoCssSiteTemplate.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Web Client/HTML5DemoCssSiteTemplate.zip">[Download]</a><br>
    <blockquote>Description:                                            Site template that is the solution to the HTML5 CSS tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
  <li>
    <img src="https://netbeans.org/images_www/sample-catalog/default.jpg" alt="default icon" style="padding-right:5px;position:relative;left:-28px;float:left;" >
    <b>Sample: HTML5DemoSiteTemplate.zip</b> <a href="https://netbeans.org/projects/samples/downloads/download/Samples/Web Client/HTML5DemoSiteTemplate.zip">[Download]</a><br>
    <blockquote>Description:                                            Site Template used in HTML5 CSS tutorial <br>                    Tags:  --                                       </blockquote>
    <div class="clear"></div>  </li>
</ul>
</li>
</ul>
</li>
</ul>

    <!-- Browsing Kenai's project downloads: Done. -->


        <h2 style="margin-right:282px">Where to Find More Samples</h2>
        <p>
            In addition to the samples listed in the tree on this page, there are plenty of samples bundled with the IDE. To open the IDE bundled samples, choose File &gt; New Project and select the Samples category.
        </p>


     <script type="text/javascript" language="javascript1.2"><!--
     compactMenu('collapsableList',true,'&plusmn; ');
     //--></script>

    </body>
</html>