<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
  <title>Welcome to NetBeans and www.netbeans.org, Home of The Open Source Java IDE</title>
  <meta name="description" content="Welcome, and Introduction to NetBeans, in English/French/your-language-here!">
  <meta http-equiv="content-type" content="text/html; charset=UTF-8">
  <meta http-equiv="content-language" content="your-language">
  <link rel="STYLESHEET" href="/netbeans.css" type="text/css">

<!-- PLEASE NOTE : If you translate this file into your language,  -->
<!-- please send a notification to webteam@netbeans.org, so we can -->
<!-- put the file up on the website and use it!                    -->

</head>
<body>
<h1>Welcome to the NetBeans Project and Netbeans.org</h1>

<!-- Translators : no need to translate this text START ========== -->
<i>NOTE<b>: </b> This page is intended as a template for translating the netbeans.org homepage
into other languages.  See <a href="../contribute/localise.html">Localisation Quick Start</a>
for more info.  If you want to translate this page into your native
language, <a href="mailto:webteam@netbeans.org">please let us know</a>!
And please <a href="https://netbeans.org/community/articles/welcome-template.html?print=yes">use 
the print version (without navigation wrappers etc)</a> for the translation.</i>
<!-- Translators : no need to translate this text STOP =========== -->

<hr noshade="noshade" size="1">

<h4>Welcome to the home of NetBeans, the Open-Source Java IDE.</h4>

<h3>What is NetBeans?</h3>

<p>
NetBeans is a successful open-source project with a very large
user base, a vibrant developer community, and over 100 global partners. 
Sun Microsystems founded and sponsored the NetBeans open-source
project in June 2000. After acquiring Sun Microsystems in 2010, Oracle took over the project's sponsorship.
</p>



<p>Two products exist: The NetBeans IDE and the NetBeans Platform.</p>




<p>
The <a href="https://netbeans.org/features/ide/index.html">NetBeans IDE</a>
is a development environment, a tool for programmers to write,
compile, debug and deploy programs.  It is written in Java but can be used for any programming language. A vast number of
modules exist with which to extend the NetBeans IDE.  The NetBeans IDE is a free
product with no restrictions on how it can be used. The <a href="https://netbeans.org/features/platform/index.html">NetBeans Platform</a> is a modular and extensible foundation for
creating large desktop applications.  ISV partners provide value-added
plugins that easily integrate into the Platform and that can also be used to
develop their own tools and solutions.
</p>



<p>Both products are open-source and free for commercial and non-commercial use.
The source code is available for reuse under the
<a href="https://netbeans.org/cddl-gplv2.html">Common Development 
and Distribution License ( CDDL) v1.0 and the GNU General Public License (GPL) v2</a>.
</p>




<h3>What is NetBeans.org?</h3>



<p>NetBeans.org is the home of the NetBeans open-source project and
community. Through NetBeans.org users worldwide are connected to the
resources and people associated with the NetBeans project. Users can
download the
latest versions of NetBeans software, contribute code, view tutorials
and support documentation, strengthen their knowledge of Java, follow
NetBeans news, join mailing lists,
learn about the people involved project, make
contacts, and much more.
</p>



<h3>Join the NetBeans Community</h3>



<p>
Become a part of the NetBeans community and help make NetBeans even better!
By registering you will be contributing directly to the success
of NetBeans and in return we will keep you informed of the latest news about the project.  Use the registration box at the
top right of this page: Simply choose a username and join!
</p>



<h3>Stay Informed</h3>



<p>
NetBeans offers a variety of mailing lists to accommodate your
level of interest and foster communication between NetBeans users.
See the <a href="https://netbeans.org/community/lists/index.html">NetBeans mailing lists page</a> to learn more about NetBeans mailing lists.
</p>




<p>Quick Links :
</p>

<ul>

<li><p>Weekly Newsletter: <a href="mailto:sympa@netbeans.org?subject=subscribe%20nbweekly">Subscribe to NetBeans Newsletter</a> (<a href="https://netbeans.org/community/news/newsletter/">Archives and More info</a>)<br>
</p></li>
  <li>
    <p>Software Announcements:
<a href="mailto:sympa@netbeans.org?subject=subscribe%20nbannounce">Subscribe to nbannounce</a>
(<a href="https://netbeans.org/community/lists/top.html">More info</a>)
    </p>
<p>
</p></li>
<li><p>Communicate with other NetBeans users:
<a href="mailto:sympa@netbeans.org?subject=subscribe%20nbusers">Subscribe to nbusers</a>
(<a href="https://netbeans.org/community/lists/top.html">More info</a>)
</p></li>
</ul>

<h3>Mailing Lists in Your Language</h3>
<i>The nbdiscuss_xx@netbeans.org lists is a general discussion list for
NetBeans related issues, tips and tricks, and more in XX!
<a href="mailto:nbdiscuss_xx-subscribe@netbeans.org">Subscribe to nbdiscuss_xx@netbeans.org</a>.<br>
<br>
</i>
<!-- Translators : no need to translate this text START ========== -->
<i>NOTE: Netbeans.org hosts mailing lists in several
languages.  See the <a href="../lists/top.html#localised">lists page</a> for
current localised mailing lists. If your language is mentioned there,
you should translate the text above to mention the localised mailing
list. If there is no list for your language and you would like to start
and help to to run one,
<a href="mailto:webteam@netbeans.org">please let us know!</a></i>
<!-- Translators : OPTIONAL, if list in your language exists STOP -->


<h3>Download NetBeans!</h3>




<p>Download the latest version of the <a href="https://netbeans.org/downloads">NetBeans IDE and NetBeans Platform</a>.

</p>


<hr noshade="noshade" size="1">
<i>Content below will appear in the right column.</i>
<hr noshade="noshade" size="1">
<p>

<!-- Register ================================================== -->
</p>


<h2>Join Netbeans.org!</h2>



<p><b><a href="https://netbeans.org/people/new">Join the NetBeans Project</a></b> and be a part of the community around a world-class IDE!</p>


<br>


<div class="nic18">&nbsp;</div>





<br clear="all">



<!-- Downloads ================================================== -->

<h2>Downloads</h2>



<div class="rarticle">
  <div class="rarticletitle"><a href="https://netbeans.org/downloads/index.html" class="leftmenu">Latest Release</a></div>
</div>




<div class="rarticle">
  <div class="rarticletitle"><a href="http://plugins.netbeans.org/" class="leftmenu">Plugin Catalogue</a></div>
</div>




<div class="nic18">&nbsp;</div>




<h2>Get Involved!</h2>

<p>NetBeans is an open source project where your participation counts!
There are many ways to contribute: Help to answer users' questions on
the
mailing list; translate the NetBeans IDE, NetBeans Platform or
NetBeans.org website content into your language; volunteer to test
software; and contribute code!
</p>





<div id="articleall"><img style="width: 14px; height: 10px;" src="/images_www/v4/arr_r.gif" alt="" border="0"><a href="/community/contribute/index.html">How to Contribute</a></div>



<!-- End right column =========================================== -->


</body></html>
