# IntelliJ IDEA overview

> For the complete documentation index, see [llms.txt](https://www.jetbrains.com/help/idea/2026.3/llms.txt).

IntelliJ IDEA is an Integrated Development Environment (IDE) for Java and Kotlin development, whether you are coding manually or working with an agent. It helps you understand existing codebase, write and modify code, run applications and tests, debug problems, and verify your changes.

You can write and edit code yourself using available development tools.  When you want additional assistance, you can use AI to help generate, explain, or modify code while you stay in control of the implementation. For larger tasks, you can delegate work to an AI agent. The IDE gives you the tools to review the agent's work, supervise its progress, and stay in control of the changes.

## Supported languages

The development of modern applications involves using multiple languages, tools, frameworks, and technologies. IntelliJ IDEA is designed as an IDE for JVM languages, but numerous [plugins](managing-plugins.html) can extend it.

### JVM languages

Use IntelliJ IDEA to develop applications in the following languages that can be compiled into the JVM bytecode, namely:

* ![](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.fileTypes.java.svg) [Java](https://www.oracle.com/java/technologies/javase-downloads.html)

* ![](https://resources.jetbrains.com/help/img/idea/2026.3/jetbrains.mps.kotlin.icons.kotlin.svg) [Kotlin](https://kotlinlang.org/)

* ![](https://resources.jetbrains.com/help/img/idea/2026.3/scalaCommunity.org.jetbrains.plugins.scala.images.expui.scalaFile.svg) [Scala](https://www.scala-lang.org/)

* ![](https://resources.jetbrains.com/help/img/idea/2026.3/intellij.platform.icons.expui.fileTypes.groovy.png) [Groovy](https://groovy-lang.org/)

### Other languages

Plugins add support for some of the most popular languages, namely:

* [Python](python.html) (full [PyCharm](https://www.jetbrains.com/pycharm) functionality)

* [Ruby](ruby-plugin.html) (full [RubyMine](https://www.jetbrains.com/ruby) functionality)

* [PHP](php.html) (full [PhpStorm](https://www.jetbrains.com/phpstorm) functionality)

* [SQL](relational-databases.html) (full [DataGrip](https://www.jetbrains.com/datagrip) functionality)

* [Go](go-plugin.html) (full [GoLand](https://www.jetbrains.com/go) functionality)

* [JavaScript](javascript-specific-guidelines.html) (full [WebStorm](https://www.jetbrains.com/webstorm) functionality)

* C/C++ (full [CLion](https://www.jetbrains.com/clion/) functionality)

* [TypeScript](typescript-support.html) (full [WebStorm](https://www.jetbrains.com/webstorm) functionality)

* [Thymeleaf](thymeleaf.html)

* [JSON](json.html)

* [Markdown](markdown.html)

* [HTML](editing-html-files.html)

* [XML and XSL](working-with-xml.html)

* [XPath and XSLT](xpath-and-xslt-support.html)

* [Velocity and FreeMarker](template-data-languages.html)

* [Stylesheets](style-sheets.html) (CSS, Less, Sass)

You can browse [JetBrains Marketplace](https://plugins.jetbrains.com/) to find an official plugin that adds support for almost any language, framework or technology used today, or for third-party plugins. For more information about managing plugins, refer to [Plugins](managing-plugins.html).

### Do I need a language plugin for IntelliJ IDEA or a separate IDE?

IntelliJ IDEA is a superset of most IntelliJ platform-based IDEs. If the bundled language plugins are enabled, it includes support for all technologies that are available within our more specific IDEs, such as [PyCharm](https://www.jetbrains.com/pycharm/), [WebStorm](https://www.jetbrains.com/webstorm/), [PhpStorm](https://www.jetbrains.com/phpstorm/), and so on.

So, for example, if your application's codebase is mainly in Java but it also uses Python scripts, we recommend using IntelliJ IDEA in combination with the bundled Python plugin. If your codebase is mainly in Python, [PyCharm](https://www.jetbrains.com/pycharm/) is the right IDE for you.

## Frameworks

### Spring

Develop Spring ![](https://resources.jetbrains.com/help/img/idea/2026.3/spring.icons.expui.spring.svg) applications with dedicated coding assistance for Spring and Spring Boot. IntelliJ IDEA provides Spring-aware code completion, inspections, navigation, project generation, diagrams, and tools for running and debugging your applications. Learn more from [Spring](spring-support.html).

### JakartaEE

Build enterprise Java applications with support for Jakarta EE ![](https://resources.jetbrains.com/help/img/idea/2026.3/intellij.java.ultimate.icons.icons.javaee.jakartaEE.png). IntelliJ IDEA provides coding assistance, navigation, dedicated project creation, application server integration, and support for specifications such as CDI, JPA, JAX-RS, Servlets, and JSP. Learn more from [Jakarta EE](java-ee.html).

### Other frameworks

IntelliJ IDEA supports a wide range of frameworks and technologies beyond Java and Kotlin. You can work with web technologies, popular JavaScript and TypeScript frameworks, Markdown, databases, build tools, and many more.

Learn more from:

* [Web development](web-development.html)

* [Database Tools and SQL](relational-databases.html)

* [Non-JVM technologies](non-jvm-technologies.html)

## Ways to work in IntelliJ IDEA

IntelliJ IDEA supports different development approaches. You can choose the style that works best for your task.

* Work directly with code Work directly with your code when you want full control over every change. IntelliJ IDEA helps you write, understand, navigate, inspect, and refactor code, as well as run, test, and debug your application.

* Work with AI assistance Use AI assistance to write, explain, test, or refactor code. AI assistance appears inline in the editor as suggestions and intention actions, and you decide what to accept or modify.

* Delegate work to an agent For larger tasks, delegate work to an AI agent. The agent can explore your project, modify files, and run commands and tests. Use IntelliJ IDEA to supervise its work, review the changes, and refine or verify the result.

* Combine approaches Switch between these approaches as you work. You might ask an agent to investigate a bug and then debug the fix yourself, or use AI assistance to write code and refine it manually. You decide when to work directly, use AI assistance, or delegate to an agent.

## Understand your code

When working with unfamiliar code or a complex codebase, you need to understand structure, find where behavior is implemented, and trace dependencies. IntelliJ IDEA provides fast navigation and search to help you explore code.

### Search and navigate

Press `Double Shift` to open Search Everywhere, then start typing. IntelliJ IDEA searches across all files, classes, symbols, and IDE actions in your project:

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/search_everywhere_screencast.mp4)

Common navigation tasks:

| Action | Shortcut |
| --- | --- |
| Search everywhere | `Double Shift` |
| Go to file | `Ctrl+Shift+N` (Windows), `⌘ ⇧ O` (macOS), `⌘ ⇧ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ O` (macOS System Shortcuts), `Ctrl+Shift+N` (XWin), `Ctrl+Shift+N` (GNOME), `Ctrl+Shift+N` (KDE), `Ctrl+X, Ctrl+F` (Emacs), `Ctrl+P` (Sublime Text), `⌘ P` (Sublime Text (macOS)), `Ctrl+Shift+T` (Visual Studio), `⌘ ⇧ T` (Visual Studio (macOS)), `Alt+Shift+O` (NetBeans), `Ctrl+Shift+R` (Eclipse), `⌘ ⇧ R` (Eclipse (macOS)) |
| Go to class | `Ctrl+N` (Windows), `⌘ O` (macOS), `⌘ N` (IntelliJ IDEA Classic (macOS)), `⌘ O` (macOS System Shortcuts), `Ctrl+N` (XWin), `Ctrl+N` (GNOME), `Ctrl+N` (KDE), `Alt+Shift+G` (Emacs), `Ctrl+N` (Sublime Text), `Ctrl+N` (Sublime Text (macOS)), `Ctrl+N` (Visual Studio), `Ctrl+N` (Visual Studio (macOS)), `Ctrl+O` (NetBeans), `Ctrl+Shift+T` (Eclipse), `⌘ ⇧ T` (Eclipse (macOS)) |
| Go to symbol | `Ctrl+Alt+Shift+N` (Windows), `⌘ ⌥ O` (macOS), `⌘ ⌥ ⇧ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ O` (macOS System Shortcuts), `Ctrl+Alt+Shift+N` (XWin), `Ctrl+Alt+Shift+N` (GNOME), `Ctrl+Alt+Shift+N` (KDE), `Ctrl+Alt+Shift+N` (Emacs), `Ctrl+Shift+R` (Sublime Text), `⌘ ⇧ R` (Sublime Text (macOS)), `Ctrl+Alt+Shift+T` (Visual Studio), `⌘ ⌥ ⇧ T` (Visual Studio (macOS)), `Ctrl+Alt+Shift+O` (NetBeans), `Ctrl+Alt+Shift+N` (Eclipse), `⌘ ⌥ O` (Eclipse (macOS)) |
| Go to declaration | `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS)) |

For more details, refer to [Source code navigation](navigating-through-the-source-code.html).

### View code structure

Press `Ctrl+F12` (Windows), `⌘ F12` (macOS), `⌘ F12` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ 7` (macOS System Shortcuts), `Ctrl+F12` (XWin), `Ctrl+F12` (GNOME), `Ctrl+0` (KDE), `Ctrl+F12` (Emacs), `Ctrl+R` (Sublime Text), `⌘ R` (Sublime Text (macOS)), `Alt+\` (Visual Studio), `⌥ \` (Visual Studio (macOS)), `Ctrl+F12` (NetBeans), `Ctrl+F3` (Eclipse), `⌘ O` (Eclipse (macOS)) to see an overview of all declarations in the current file and jump to any of them. Alternatively, use the Structure tool window (`Alt+7` (Windows), `⌘ 7` (macOS), `⌘ 7` (IntelliJ IDEA Classic (macOS)), `⌘ 7` (macOS System Shortcuts), `Alt+7` (XWin), `Alt+7` (GNOME), `Alt+7` (KDE), `Alt+7` (Emacs), `Alt+7` (Sublime Text), `⌘ 7` (Sublime Text (macOS)), `Ctrl+Alt+F` (Visual Studio), `⌃ ⌥ F` (Visual Studio (macOS)), `Ctrl+7` (NetBeans), `Alt+7` (Eclipse), `⌘ 7` (Eclipse (macOS))):

![File structure popup](https://resources.jetbrains.com/help/img/idea/2026.3/ij_file_structure.png)

### Access recent files and edits

Normally, you work with a small subset of files at a time and need to switch between them quickly. The Recent Files action is a real time-saver here. Press `Ctrl+E` (Windows), `⌘ E` (macOS), `⌘ E` (IntelliJ IDEA Classic (macOS)), `⌘ E` (macOS System Shortcuts), `Ctrl+E` (XWin), `Ctrl+E` (GNOME), `Ctrl+E` (KDE), `Ctrl+E` (Emacs), `Ctrl+E` (Sublime Text), `⌘ E` (Sublime Text (macOS)), `Ctrl+Comma` (Visual Studio), `⌃ Comma` (Visual Studio (macOS)), `Shift+F4` (NetBeans), `Ctrl+E` (Eclipse), `⌘ E` (Eclipse (macOS)) to see a list of last accessed files. Note that you can also use this action to open any tool window:

![Recent Files popup](https://resources.jetbrains.com/help/img/idea/2026.3/ij_recent_files.png)

Apart from jumping to a recent file, you can also get quick access to Recent Locations: the code snippets you last viewed or edited. Press `Ctrl+Shift+E` (Windows), `⌘ ⇧ E` (macOS), `⌘ ⇧ E` (IntelliJ IDEA Classic (macOS)), `⌘ ⇧ E` (macOS System Shortcuts), `Ctrl+Shift+E` (XWin), `Ctrl+Shift+E` (GNOME), `Ctrl+Shift+E` (KDE), `Ctrl+Shift+E` (Emacs), `Ctrl+Shift+E` (Sublime Text), `⌘ ⇧ E` (Sublime Text (macOS)), `Ctrl+Shift+E` (Visual Studio), `Ctrl+Shift+E` (Visual Studio (macOS)), `Ctrl+Shift+E` (NetBeans), `Ctrl+Shift+E` (Eclipse), `⌘ ⇧ E` (Eclipse (macOS)) and you'll be able to jump to a particular line you modified lately:

![Recent Files popup](https://resources.jetbrains.com/help/img/idea/2026.3/recent_locations_popup.png)

## Create and change code

### Edit and complete code

IntelliJ IDEA provides inline code completion, templates, and other editing aids to speed up typing. For more information, refer to [Code completion](auto-completing-code.html) and [Live templates](using-live-templates.html).

### Inspect and fix problems

As you write or generate code, IntelliJ IDEA continuously analyzes it to find potential bugs, dead code, performance issues, and style problems. When it detects an issue, it shows a light bulb icon. Press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) to see quick-fixes and intention actions:

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/inspection-fix.mp4)

Quick-fixes resolve problems across your project. Intention actions help you apply transformations like extracting code, adding annotations, or converting syntax. Learn more from [Code inspections](code-inspection.html) and [Intention actions](intention-actions.html).

### Refactor safely

Use refactorings to restructure code while maintaining correctness. Press `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS)) to see available refactorings for your current context:

![Refactor This popup](https://resources.jetbrains.com/help/img/idea/2026.3/refactoring_invoke.png)

IntelliJ IDEA automatically updates all references across your project when you refactor. Learn more from [Refactoring code](refactoring-source-code.html).

Common refactoring shortcuts:

| Action | Shortcut |
| --- | --- |
| Refactor this | `Ctrl+Alt+Shift+T` (Windows), `⌃ T` (macOS), `⌘ ⌥ ⇧ T` (IntelliJ IDEA Classic (macOS)), `⌃ S` (macOS System Shortcuts), `Ctrl+Alt+Shift+T` (XWin), `Ctrl+Alt+Shift+T` (GNOME), `Ctrl+Alt+Shift+T` (KDE), `Ctrl+Alt+Shift+T` (Emacs), `Ctrl+Alt+Shift+T` (Sublime Text), `⌃ T` (Sublime Text (macOS)), `Ctrl+Shift+R` (Visual Studio), `⌘ ⇧ R` (Visual Studio (macOS)), `Ctrl+Alt+Shift+T` (NetBeans), `Ctrl+Alt+Shift+T` (Eclipse), `⌃ T` (Eclipse (macOS)) |
| Rename | `Shift+F6` (Windows), `⇧ F6` (macOS), `⇧ F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ R` (macOS System Shortcuts), `Shift+F6` (XWin), `Shift+F6` (GNOME), `Shift+F6` (KDE), `Shift+F6` (Emacs), `Shift+F6` (Sublime Text), `⇧ F6` (Sublime Text (macOS)), `Ctrl+R, R` (Visual Studio), `⌘ R, R` (Visual Studio (macOS)), `Ctrl+R` (NetBeans), `Alt+Shift+R` (Eclipse), `⇧ F6` (Eclipse (macOS)) |
| Extract variable | `Ctrl+Alt+V` (Windows), `⌘ ⌥ V` (macOS), `⌘ ⌥ V` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ V` (macOS System Shortcuts), `Ctrl+Alt+V` (XWin), `Ctrl+Alt+V` (GNOME), `Alt+Shift+V` (KDE), `Ctrl+Alt+V` (Emacs), `Ctrl+Alt+V` (Sublime Text), `Ctrl+Alt+V` (Sublime Text (macOS)), `Ctrl+R, V` (Visual Studio), `⌘ R, V` (Visual Studio (macOS)), `Alt+Shift+V` (NetBeans), `Alt+Shift+L` (Eclipse), `⌘ ⌥ L` (Eclipse (macOS)) |
| Extract method | `Ctrl+Alt+M` (Windows), `⌘ ⌥ M` (macOS), `⌘ ⌥ M` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ M` (macOS System Shortcuts), `Ctrl+Alt+M` (XWin), `Ctrl+Alt+M` (GNOME), `Ctrl+Alt+M` (KDE), `Ctrl+Alt+M` (Emacs), `Ctrl+Alt+M` (Sublime Text), `⌘ ⌥ M` (Sublime Text (macOS)), `Ctrl+R, M` (Visual Studio), `⌘ R, M` (Visual Studio (macOS)), `Alt+Shift+M` (NetBeans), `Alt+Shift+M` (Eclipse), `⌘ ⌥ M` (Eclipse (macOS)) |
| Inline | `Ctrl+Alt+N` (Windows), `⌘ ⌥ N` (macOS), `⌘ ⌥ N` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ N` (macOS System Shortcuts), `Ctrl+Alt+N` (XWin), `Ctrl+Alt+N` (GNOME), `Ctrl+Alt+N` (KDE), `Ctrl+Alt+N` (Emacs), `Ctrl+Alt+N` (Sublime Text), `⌘ ⌥ N` (Sublime Text (macOS)), `Ctrl+R, I` (Visual Studio), `⌘ R, I` (Visual Studio (macOS)), `Ctrl+Alt+N` (NetBeans), `Alt+Shift+I` (Eclipse), `⌘ ⌥ I` (Eclipse (macOS)) |
| Move | `F6` (Windows), `F6` (macOS), `F6` (IntelliJ IDEA Classic (macOS)), `⌘ ⌥ I` (macOS System Shortcuts), `F6` (XWin), `F6` (GNOME), `F6` (KDE), `F6` (Emacs), `F6` (Sublime Text), `F6` (Sublime Text (macOS)), `Ctrl+R, O` (Visual Studio), `⌘ R, O` (Visual Studio (macOS)), `Ctrl+M` (NetBeans), `Alt+Shift+V` (Eclipse), `⌘ ⌥ V` (Eclipse (macOS)) |

### Delegate larger changes to an agent

For complex refactoring tasks, describe the outcome and let an agent implement the change across your codebase. You can review and continue editing the result manually afterward.

## Run and investigate

Running code, tests, and debugging are essential ways to understand runtime behavior and diagnose problems.

### Debug a problem yourself

IntelliJ IDEA provides a built-in JVM debugger that lets you get and analyze runtime information without running code with manual logging or trial-and-error approaches.

You can:

* Suspend the program execution to examine its behavior using breakpoints. Multiple types of breakpoints, together with conditions and filters, allow you to specify the exact moment when an application needs to be paused.

* Play with the program state by modifying variable values, evaluate expressions, and so on.

* Examine variable values, call stacks, thread states, and so on.

* [Control the step-by-step execution](stepping-through-the-program.html) of the program.

Refer to [Tutorial: Debug your first Java application](debugging-your-first-java-application.html) to learn the basics of debugging and play with the debugger features in the IDE.

### Let an agent investigate

For complex runtime issues, describe the problem in natural language and let an agent use the debugger to investigate. The agent can set breakpoints, step through code, and collect runtime evidence without manual intervention.

This approach is especially useful when source code and logs alone do not reveal the problem. Learn more from [Agentic debugging](agentic-debugging.html).

## Verify and review changes

Whether code was written by you, a teammate, an AI assistant, or an agent, IntelliJ IDEA helps you determine whether the change is correct and safe.

### Run tests

Write tests in the IDE and run them to verify your code works as expected. For more information, refer to [Create tests](create-tests.html).

### Review changes with version control

IntelliJ IDEA provides integration with [Git](https://git-scm.com/), [Mercurial](https://www.mercurial-scm.org/), [Perforce](https://www.perforce.com/solutions/version-control), and [Subversion](https://subversion.apache.org/).

You can:

* [Review the history](investigate-changes.html) and compare file versions

* [Manage branches](manage-branches.html) and [handle GitHub pull requests](github.html)

* Access all VCS actions via `Alt+`` (Windows), `⌃ V` (macOS), `⌃ V` (IntelliJ IDEA Classic (macOS)), `⌃ C` (macOS System Shortcuts), `Alt+`` (XWin), `Alt+`` (GNOME), `Alt+`` (KDE), `Alt+`` (Emacs), `Alt+`` (Sublime Text), `Alt+`` (Sublime Text (macOS)), `Ctrl+Alt+Q` (Visual Studio), `⌃ V` (Visual Studio (macOS)), `Alt+`` (NetBeans), `Alt+`` (Eclipse), `⌃ V` (Eclipse (macOS))

For more information, refer to [Version control](version-control-integration.html).

### Restore or revert changes

Local History keeps track of all edits to your project automatically. If you need to restore code that was deleted or changed, use Local History to browse your full revision history and restore any point in time:

![Restore code with local history](https://resources.jetbrains.com/help/img/idea/2026.3/local_history_restore_code.animated.gif)

Even without version control enabled, Local History acts as your personal version control system.

## Delegate and supervise agent work

When you delegate work to an agent, you remain in control throughout the process.

### Choose your agent

IntelliJ IDEA supports agents through the Agent Client Protocol (ACP). Agents available in IntelliJ IDEA include Junie, Claude Agent, and Codex. You can also bring your own ACP-compatible agent. Learn more from [Browse, install, and update agents](https://www.jetbrains.com/help/air-ides/air-manage-agents.html) (Air documentation).

### Extend agent capabilities

Agents can be extended with Agent Skills and Model Context Protocol (MCP) integrations. Skills provide reusable instructions for specific tasks. IntelliJ IDEA includes bundled skills. For example, `ij-debugger` allows agents to investigate runtime problems.

For details, refer to [MCP](mcp-server.html) and [agent skills](agentic-debugging.html#install-skill).

### Configure AI providers

IntelliJ IDEA allows you to configure API keys or endpoints for third-party AI providers. This means your AI setup is not limited to a single agent, model, or built-in capability. Learn more from [Configure agent authorization](https://www.jetbrains.com/help/air-ides/air-configure-authorization.html) (Air documentation).

## Integrated developer tools

IntelliJ IDEA includes built-in support for essential development tasks.

### Terminal

IntelliJ IDEA includes a built-in [terminal](terminal-emulator.html) for running shell commands from inside the IDE. It supports your system's default shell and others like `bash` and `sh`.

### Build tools

IntelliJ IDEA provides full support for [Gradle](https://gradle.org/) and [Maven](https://maven.apache.org/). When you open or create a Gradle or Maven project, IntelliJ IDEA automatically detects and downloads required dependencies. You can edit build files directly and configure automatic synchronization. For more information, refer to [Gradle](gradle.html) and [Maven](maven-support.html).

## IntelliJ IDEA editions

Previously, IntelliJ IDEA was offered as two separate products: IntelliJ IDEA Community Edition and IntelliJ IDEA Ultimate with extended capabilities.

Starting with IntelliJ IDEA 2025.3, we're combining these two editions into a single, unified product: IntelliJ IDEA. This change allows all users to access essential functionality without needing to decide between editions.

The core functionality of IntelliJ IDEA remains free and now comes with even more features compared to the former Community Edition. Additionally, the new Ultimate subscription gives you access to advanced tooling with a free 30-day trial available for all users when installing IntelliJ IDEA.

Afterward, you can choose to subscribe or continue using IntelliJ IDEA for free.

For more information about the Ultimate subscription, refer to the [comparison matrix](https://www.jetbrains.com/idea/features/editions_comparison_matrix.html).

### The Early Access program

IntelliJ IDEAis available for free within the [Early Access Program (EAP)](https://www.jetbrains.com/resources/eap/). EAP builds are published before the release of a stable product version, and you can download them to try out the new features before they are publicly available in return for your feedback. EAP builds are configured to collect feature usage statistics and are a valuable source of information for our developers. You can also [report an issue](https://youtrack.jetbrains.com/newIssue?draftId=25-2721599) if you encounter any problems.

> **Note:**
> Release Candidate (RC) builds published before a release are also available for download but require a paid license.
>
>
>
> Preview builds published after the release of a stable version that are followed by an official update, also require a paid license and cannot be evaluated for free.

## Shortcuts for everything

In IntelliJ IDEA, you have shortcuts for nearly every action, including selection and switching between the editor and various tool windows.

[Use the most useful shortcuts](mastering-keyboard-shortcuts.html) to invoke frequent actions without switching your focus from the editor and [tune your keymap](configuring-keyboard-and-mouse-shortcuts.html) to assign custom shortcuts for your favorite commands.

Watch this video to learn about some of the most useful shortcuts:

[Video](https://www.youtube.com/v/QYO5_riePOQ)

## What's next

* [Get started with Air](air-quickstart-guide.html) to get a complete agentic development experience for directing and orchestrating agents and verifying their work inside IntelliJ IDEA.

* Learn the most useful tips for working with the IDE from [IntelliJ IDEA tutorials](instance-tutorials.html).

* Learn how to [use most popular Git actions in IntelliJ IDEA](working-with-git-tutorial.html).

## See also

### External Links

[IntelliJ IDEA Tips and Tricks](http://blog.jetbrains.com/idea/2015/10/intellij-idea-tips-and-tricks/) [IntelliJ IDEA video tutorials](https://www.jetbrains.com/idea/documentation/)