# Migrate from NetBeans to IntelliJ IDEA Switching from NetBeans to IntelliJ IDEA requires understanding of the differences between the two IDEs. This section covers some IntelliJ IDEA-specific aspects. ## Import a project to IntelliJ IDEA Procedure: 1. Launch IntelliJ IDEA. If the [Welcome screen](run-for-the-first-time.html#start-project) opens, click Open. Otherwise, go to `File | Open` in the main menu. 2. In the dialog that opens, select the directory in which your sources, libraries, and other assets are located and click Open. If you are using Maven with NetBeans, and you want to import a Maven project into IntelliJ IDEA, select your project's `pom.xml`. 3. In the Open Project dialog that opens, click New Window. IntelliJ IDEA will add the `.idea` directory to your project. This is used to store the IntelliJ IDEA [project settings](configure-project-settings.html) such as VCS settings, [inspection profiles](customizing-profiles.html), or [code styles](configuring-code-style.html). The NetBeans `.nbproject` directory and the `build.xml` file will remain untouched, and you'll be able to use IntelliJ IDEA along with NetBeans. If you used NetBeans with Ant, keep in mind that the [Ant](ant.html) plugin is unbundled. IntelliJ IDEA is fully integrated with Maven and Gradle. If you use one of these build tools, refer to [Maven](maven.html) and [Gradle](gradle.html) for more information about working with them in IntelliJ IDEA. ## User Interface ### Terminology differences NetBeans and IntelliJ IDEA use different names for similar entities. The following table maps the most important NetBeans concepts to IntelliJ IDEA ones. | NetBeans | IntelliJ IDEA | | --- | --- | | Project | Module | | Global library | Global library | | Project library | Module library | | Project dependency | Module dependency | ### Projects IntelliJ IDEA creates a project for an entire code base and a module for each of its individual components. NetBeans projects are more like IntelliJ IDEA modules. Unlike NetBeans, IntelliJ IDEA cannot open multiple projects in the same window. When you open a project, you have to choose whether to open it in a new window or to close the current project and open a new one instead. For more information, refer to [Open, move, and close projects](open-close-and-move-projects.html). > **Tip:** > If you want to work on multiple NetBeans projects at the same time, you can [import them as modules](creating-and-managing-modules.html#import-module-from-sources). ### Project groups In NetBeans, a project group is a way to organize projects you are currently working on. Projects of the same group are opened in the same window; you can switch between projects groups without leaving the IDE. In IntelliJ IDEA, you open one project per window, so you don't have an equivalent for NetBeans project groups. You can encounter this term when you [group your recent projects](open-close-and-move-projects.html#group-projects) on the Welcome screen, but these groups do not appear on the Project tool window. ### Modules Both NetBeans and IntelliJ IDEA had already had their modules before the Java 9 modular system was introduced. In NetBeans, a module is a type of project within a NetBeans Platform application. In IntelliJ IDEA, a module is an essential part of any project: when you create a project, you'll have at least one module. In NetBeans, a module is identified by its `MANIFEST.MF` file, while each IntelliJ IDEA module has the `.iml` file, which keeps its configuration. NetBeans modules can belong to a module suite. It is another type of project, which facilitates the deployment of multiple interdependent modules on top of NetBeans. In IntelliJ IDEA, you can also [group modules](creating-and-managing-modules.html#group-by-qualified-names), but, unlike in NetBeans, a module group is not a project, it's just a way to organize your modules and quickly build them within the same project. ### Options dialog The equivalent of the NetBeans Options dialog is the `File | Settings` (for Windows and Linux) or `IntelliJ IDEA | Preferences` (for macOS) dialog. You can open it by pressing `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)). This dialog is used to control behavior and appearance of IntelliJ IDEA. ![Settings | Appearance & Behavior | Appearance](https://resources.jetbrains.com/help/img/idea/2026.2/ij-settings-appearance.png) You can also use the Project Structure dialog (`Ctrl+Alt+Shift+S` (Windows), `⌘ ;` (macOS), `⌘ ;` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ Comma` (macOS System Shortcuts), `Ctrl+Alt+Shift+S` (XWin), `Ctrl+Alt+Shift+S` (GNOME), `Ctrl+Alt+Shift+S` (KDE), `Ctrl+Alt+Shift+S` (Emacs), `Ctrl+Alt+Shift+S` (Sublime Text), `⌘ ;` (Sublime Text (macOS)), `Ctrl+Alt+Shift+S` (NetBeans), `Ctrl+Alt+Shift+S` (Visual Studio), `⌘ ;` (Visual Studio (macOS)), `Ctrl+Alt+Shift+S` (Eclipse), `⌘ ;` (Eclipse (macOS))) to manage JDKs, libraries, module dependencies, and so on, similarly to the Project Properties dialog in NetBeans. ### Use NetBeans key bindings IntelliJ IDEA includes several predefined keymaps, including NetBeans. Procedure: 1. In the Settings dialog (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))), select Keymap. 2. In the right-hand part of the dialog, under Keymap, select NetBeans. If you want to customize some of the shortcuts of the predefined keymaps, refer to [IntelliJ IDEA keyboard shortcuts](mastering-keyboard-shortcuts.html). ## Work with Projects Most of the options available in the Project Properties dialog in NetBeans are available in `File | Project Structure | Project Settings | Project` in IntelliJ IDEA. ### Set the project JDK Setting the JDK for a project consists of two steps: Procedure: 1. Register a JDK in the IDE so that the IDE knows in which folder on your computer the necessary JDK version is installed. * In NetBeans, this setting is available in `Tools | Java Platforms`. * In IntelliJ IDEA, you do it in `File | Project Structure | Platform Settings | SDKs`. 2. Select a JDK for a project: * In NetBeans, this setting is available in the `Project Properties | Libraries` dialog. * In IntelliJ IDEA, you do it in `File | Project Structure | Project Settings | Project`. For more information about working with JDKs in IntelliJ IDEA, refer to [SDKs](sdk.html). ### Define libraries Just like in NetBeans, in IntelliJ IDEA you can use global libraries, which are available for all projects, and project libraries. You can define global libraries in `File | Project Structure | Platform Settings | Global Libraries` and project libraries in `File | Project Structure | Project Settings | Libraries`. For detailed instructions, refer to [Libraries](library.html). ### Add support for a web framework Framework support is enabled at the module level. > **Note:** > This information is valid for projects that are built with the native IntelliJ IDEA builder. If you're using a build tool, such as [Maven](maven-support.html) or [Gradle](gradle.html), make all changes using the build file. Procedure: 1. In the Project tool window (`Alt+1` (Windows), `⌘ 1` (macOS), `⌘ 1` (IntelliJ IDEA Classic (macOS)), `⌘ 1` (macOS System Shortcuts), `Alt+1` (XWin), `Alt+1` (GNOME), `Alt+1` (KDE), `Alt+1` (Emacs), `Alt+1` (Sublime Text), `⌘ 1` (Sublime Text (macOS)), `Ctrl+1` (NetBeans), `Ctrl+Alt+L` (Visual Studio), `⌘ ⌥ L` (Visual Studio (macOS)), `Alt+1` (Eclipse), `Alt+1` (Eclipse (macOS))) , select the necessary module. 2. Press `Ctrl+Shift+A` (Windows), `⌘ ⇧ A` (macOS), `⌘ ⇧ A` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ P` (macOS System Shortcuts), `Ctrl+Shift+A` (XWin), `Ctrl+Shift+A` (GNOME), `Ctrl+Shift+A` (KDE), `Escape, X` (Emacs), `Ctrl+Shift+P` (Sublime Text), `⌘ ⇧ P` (Sublime Text (macOS)), `Ctrl+I` (NetBeans), `Ctrl+Shift+A` (Visual Studio), `⌘ ⇧ A` (Visual Studio (macOS)), `Ctrl+Shift+A` (Eclipse), `⌘ 3` (Eclipse (macOS)) and type `Add Framework Support`. Once the action is found, click it to open the Add Framework Support dialog. 3. In the dialog that opens, select Web Application and select a version of the Servlet specification. 4. If you want the deployment descriptor `web.xml` file to be created, select the `Create web.xml` checkbox. Click OK. ![Adding support for a framework](https://resources.jetbrains.com/help/img/idea/2026.2/ij_add_framework_support.png) You can also enable support for a web framework while creating a new project. For more information, refer to [Web applications](developing-web-applications.html). ### Run applications In IntelliJ IDEA, you can run your application right from the editor by clicking ![](https://resources.jetbrains.com/help/img/idea/2026.2/app.actions.execute.svg) near the declaration of a class with the `main()` method and selecting Run '.main()' . ![Running a Java application](https://resources.jetbrains.com/help/img/idea/2026.2/run_quick_1.png) Similarly to NetBeans, you can also run it from the Project tool window by right-clicking a class and selecting Run '.main()' . Additionally, if you want to pass arguments or environment variables to your program or otherwise customize its startup, you can use [run/debug configurations](run-debug-configuration.html). A run/debug configuration is a named set of startup properties. You can run the same application with different configurations if you want to change its startup logic or output. When you run your application from the editor or from the Project tool window without selecting a configuration, IntelliJ IDEA creates a temporary configuration with default values. You can then edit and save it as a permanent configuration. ![Save a temporary run configuration](https://resources.jetbrains.com/help/img/idea/2026.2/save_temporary.png) With IntelliJ IDEA, you can also create run/debug configurations based on existing configuration templates, share your configurations with teammates via XML files, and much more. For more information about running applications and managing run/debug configurations, refer to [Run applications](running-applications.html). ### Use Version Control The most popular Version Control Systems including Git, Subversion, Mercurial, Perforce, and more are supported by IntelliJ IDEA. VCS integration for your project can be configured in on the [Version Control](settings-version-control.html) page of the Settings /Preferences dialog. For more information, refer to [Version control](version-control-integration.html). ## Code editor For an overview of the IntelliJ IDEA editor, refer to [Editor basics](using-code-editor.html). ### Code completion In IntelliJ IDEA, the list of code completion suggestions appears automatically after you type one or two characters. To narrow down this list, use: * `Ctrl+Space` (Windows), `⌃ Space` (macOS), `⌃ Space` (IntelliJ IDEA Classic (macOS)), `⌃ Space` (macOS System Shortcuts), `Ctrl+Space` (XWin), `Ctrl+Space` (GNOME), `Ctrl+Space` (KDE), `Alt+/` (Emacs), `Ctrl+Space` (Sublime Text), `⌃ Space` (Sublime Text (macOS)), `Ctrl+Space` (NetBeans), `Ctrl+Space` (Visual Studio), `⌃ Space` (Visual Studio (macOS)), `Ctrl+Space` (Eclipse), `⌃ Space` (Eclipse (macOS)). Reduces the list to keywords and the names of classes, methods, and fields available in the current context. Note that the list changes when you press `Ctrl+Space` (Windows), `⌃ Space` (macOS), `⌃ Space` (IntelliJ IDEA Classic (macOS)), `⌃ Space` (macOS System Shortcuts), `Ctrl+Space` (XWin), `Ctrl+Space` (GNOME), `Ctrl+Space` (KDE), `Alt+/` (Emacs), `Ctrl+Space` (Sublime Text), `⌃ Space` (Sublime Text (macOS)), `Ctrl+Space` (NetBeans), `Ctrl+Space` (Visual Studio), `⌃ Space` (Visual Studio (macOS)), `Ctrl+Space` (Eclipse), `⌃ Space` (Eclipse (macOS)) for the second or third time. * `Ctrl+Shift+Space` (Windows), `⌃ ⇧ Space` (macOS), `⌃ ⇧ Space` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ Space` (macOS System Shortcuts), `Ctrl+Shift+Space` (XWin), `Ctrl+Shift+Space` (GNOME), `Ctrl+Shift+Space` (KDE), `Ctrl+Shift+Space` (Emacs), `Ctrl+Shift+Space` (Sublime Text), `Ctrl+Shift+Space` (Sublime Text (macOS)), `Ctrl+Shift+Space` (NetBeans), `Ctrl+Alt+Space` (Visual Studio), `⌃ ⌥ Space` (Visual Studio (macOS)), `Alt+Shift+Space` (Eclipse), `⌥ ⇧ Space` (Eclipse (macOS)). Shows only the types appropriate for the current context (smart type-matching code completion). With IntelliJ IDEA, you can customize many of the code completion settings. For more information, refer to [Code completion](auto-completing-code.html). ### Code templates In NetBeans, code templates are pieces of code associated with abbreviations. In IntelliJ IDEA they are known as [live templates](using-live-templates.html). Some templates are different; for example, `private static final` is abbreviated as `psf` in NetBeans while it is `prsf` in IntelliJ IDEA. ![Example of using Live Templates](https://resources.jetbrains.com/help/img/idea/2026.2/LiveTemplatesExample.animated.gif) The list of available templates can be found in `Settings | Editor | Live Templates`. There you can also add your own templates or modify any existing ones. ### Code analysis IntelliJ IDEA can analyze dependencies, data flows, and stack traces, find duplicates, and evaluate code quality. You can check available options in the `Code | Analyze Code` menu. Just like in NetBeans, you can use code inspections to detect anomalous code. In IntelliJ IDEA, inspections are highly customizable: you can disable them, suppress them for a specific piece of code, change their severity levels, and create custom inspections. For more information, refer to [Code inspections](code-inspection.html). ![Changing inspection severity by scope](https://resources.jetbrains.com/help/img/idea/2026.2/severity_by_scope.png) Similarly to hints in NetBeans, you can use [intention actions](intention-actions.html) and [quick-fixes](resolving-problems.html#apply-quick-fixes) to quickly alter or correct your code. [Video](https://resources.jetbrains.com/help/img/idea/2026.2/inspection-fix.mp4) ### Action Items In NetBeans, the Action Items tab displays TODO comments, code problems, and compiler errors. In IntelliJ IDEA, you can get similar information using the following tool windows: * TODO: view TODO comments. For more information, refer to [TODO tool window](todo-tool-window.html). * Problems: view errors and warnings found by IntelliJ IDEA inspections. For more information, refer to [Code inspections](code-inspection.html). ### Syntax highlighting Just like in NetBeans, when you place the caret at a symbol, IntelliJ IDEA highlights all usages of this symbol in the current file. In IntelliJ IDEA, you can use the Highlight on Caret Movement option to enable and disable highlighting matched braces, current scope, and usages of the element at the caret. For more information, refer to [Disable automatic highlighting of usages](find-highlight-usages.html#disable-highlighting-usages). If you want to keep highlighting occurrences of a code element while moving the caret away from it (Keep Marks option in NetBeans), in IntelliJ IDEA you can press `Ctrl+Shift+F7` (Windows), `⌘ ⇧ F7` (macOS), `⌘ ⇧ F7` (IntelliJ IDEA Classic (macOS)), `⌘ ⌃ U` (macOS System Shortcuts), `Ctrl+Shift+F7` (XWin), `Ctrl+Shift+F7` (GNOME), `Ctrl+Shift+7` (KDE), `Ctrl+Shift+F7` (Emacs), `Ctrl+Shift+F7` (Sublime Text), `⌘ ⇧ F7` (Sublime Text (macOS)), `Ctrl+Shift+F7` (NetBeans), `Alt+Shift+F11` (Visual Studio), `⌥ ⇧ F11` (Visual Studio (macOS)), `Alt+Shift+O` (Eclipse), `Ctrl+Shift+F7` (Eclipse (macOS)). ![Keep marks](https://resources.jetbrains.com/help/img/idea/2026.2/keep_marks.animated.gif) If you have many variables or a function with many parameters, you can use [semantic highlighting](configuring-colors-and-fonts.html#semantic-highlighting) to assign a different color to each parameter and local variable. Additionally, you can configure visibility-based code highlighting for public, protected, and private Java members (methods, fields, classes) in `Settings | Editor | Color Scheme | Java | Visibility`. ![Importing a project from existing sources](https://resources.jetbrains.com/help/img/idea/2026.2/ij_visibility_color_settings.png) ### Save changes Unlike NetBeans where you have to manually save your changes, IntelliJ IDEA saves them automatically. Saving is triggered by various events, such as compiling, running, debugging, performing version control operations, closing a file or a project, or quitting the IDE. Additionally, you can configure IntelliJ IDEA to trigger auto-save when switching to another application or if the IDE is idle for a specified period. ![Configure autosave behavior](https://resources.jetbrains.com/help/img/idea/2026.2/ij_autosave_triggers.png) ### Compile on save and deploy on save In NetBeans, you can enable compilation and deployment on save. In separate settings, you can configure other on-save actions such as reformat code or remove unused imports. In IntelliJ IDEA, all these actions are available in `Settings | Tools | Actions on Save`. ![Settings: Actions on save](https://resources.jetbrains.com/help/img/idea/2026.2/actions-on-save.png) For more information, refer to [Trigger actions when saving changes](saving-and-reverting-changes.html#actions-on-save) . ## Plugins Although you cannot use NetBeans plugins in IntelliJ IDEA, a lot of functionality implemented in these plugins is available in IntelliJ IDEA out of the box. Besides, there are a lot of plugins for IntelliJ IDEA, so you can always find a plugin with functionality similar to that of your favorite NetBeans plugin. You can install plugins from [JetBrains Marketplace](https://plugins.jetbrains.com/) or from the disk. Procedure: Open plugin settings * [Open settings](jetbrains://tool/settings?name=Plugins) or press `Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS)) in your IDE and then select `Plugins`. ![Plugins settings, Marketplace tab active, showing plugins list with Kubernetes and Solarized Theme; Kubernetes details on the right.](https://resources.jetbrains.com/help/img/idea/2026.2/plugins_settings.png) Use the Marketplace tab to browse and install plugins from [JetBrains Marketplace](https://plugins.jetbrains.com/) or from a [custom plugin repository](managing-plugins.html#repos). Use the Installed tab to browse bundled and installed plugins, enable, disable, update, or remove them. Disabling unnecessary plugins can increase performance. If a plugin depends on some other plugin, you can find a list of the dependencies in the Additional Info tab. If your project depends on certain plugins, add them to the list of [required plugins](). For more information, refer to [Plugins](plugins-settings.html) and [Plugins](managing-plugins.html). If you want to write a plugin for IntelliJ IDEA, have a look at: * [IntelliJ Platform SDK Developer Guide](https://plugins.jetbrains.com/docs/intellij/welcome.html). * Information for Plugin Developers on the [IntelliJ IDEA Plugins page](https://www.jetbrains.com/idea/plugins/index.html) * [Open API and Plugin Development](https://devnet.jetbrains.com/community/idea/open_api_and_plugin_development)