Set Up Java 25, IntelliJ, Hyperskill

Set up Java 25, IntelliJ IDEA, the idea CLI, and Hyperskill on macOS.

Introduction

30 Second Summary

A coding setup feels dependable when your work opens the same way every time. Small differences between apps can turn that simple routine into guesswork.

In this project, you will configure IntelliJ IDEA to use Java 25 for your development work. Your finished workspace connects Terminal to Hyperskill through the same IntelliJ IDEA project.

What You'll Build

You will watch Hello World print from a Java 25 project launched directly from Terminal into IntelliJ IDEA.

By the end of this project, you'll have:

  • A verified Java 25 toolchain that shows Java 25 for both java and javac.
  • A working idea launcher that reveals the difference between one file in LightEdit versus the complete ~/MyProject workspace.
  • A Hyperskill workspace that opens supported Java content with JDK 25 selected.
  • Secret Mission: Use --wait so Terminal pauses until you close a file in LightEdit.

Are there any prerequisites?

You need an Apple Silicon Mac with administrator access plus internet access. Your starting point includes IntelliJ IDEA, Java, and an existing Hyperskill account.

Before We Start

Before the hands-on work begins, this checkpoint helps you commit to configuring a Java 25 workspace in IntelliJ IDEA for your Hyperskill Java project. Your goal is to open the complete project from Terminal through the idea command.

Verify IntelliJ IDEA and Java 25

IntelliJ IDEA can run on its bundled runtime even when your Java projects use a separate JDK.

This step checks the IDE version separately from the development JDK. You will also create the project that anchors every later launcher test.

In this step, get ready to:
  • Confirm IntelliJ IDEA 2026.2.3 is installed and open.
  • Install and verify Oracle JDK 25.0.4.1.
  • Create ~/MyProject with the two starter files.
Verify the IntelliJ IDEA version

The About dialog identifies the exact IntelliJ IDEA release installed on your Mac. The target for this project is 2026.2.3.

  • Open Spotlight by pressing Cmd+Space.

You will see the Spotlight search field.

  • Type IntelliJ IDEA into Spotlight.

You will see IntelliJ IDEA in the search results.

  • Press Enter to open IntelliJ IDEA.
  • Select the IntelliJ IDEA app menu at the top of the screen.
  • Select About to display the installed version.

✔️ I see version 2026.2.3

Your IDE matches the project target. Keep this installation open for the remaining setup.

ⓧ I see an older version

The built-in updater handles the upgrade inside IntelliJ IDEA. It may ask you to relaunch the application after downloading the update.

  • Use the updater control in the About dialog to install IntelliJ IDEA 2026.2.3.
  • Relaunch IntelliJ IDEA when the updater prompts you.
  • Return to the About dialog.
  • Confirm the dialog now shows 2026.2.3.

ⓧ I cannot find IntelliJ IDEA

Use the official IntelliJ IDEA installation guide to install the current macOS release.

  • Follow the macOS installation instructions for your Apple Silicon Mac.
  • Open IntelliJ IDEA through Spotlight after the installation finishes.
  • Open the About dialog.
  • Confirm the installed version is 2026.2.3.

Good progress. IntelliJ IDEA now supports the Java 25 workspace you are about to create.

Verify Java 25 with macOS Terminal

A standalone JDK provides the Java compiler used by your project. Checking macOS Terminal proves Java is available outside the IDE.

  • Open Spotlight by pressing Cmd+Space.

You will see the Spotlight search field again.

  • Type Terminal into Spotlight.

You will see Terminal in the search results.

  • Press Enter to open macOS Terminal.
  • Check the default Java version by running this command:
java -version

What does this check?

The java -version command reports the Java runtime selected by the current Terminal environment. Its version line reveals whether Java 25.0.4.1 is already the default.

✔️ I see version 25.0.4.1

Oracle JDK 25.0.4.1 is already available. Continue to the common verification below.

ⓧ I see an older version

The installer asks for administrator approval because it places the JDK in the system Java directory. Your existing Java installation can remain available for other projects.

  • Download the official Apple Silicon JDK installer.
  • Open jdk-25_macos-aarch64_bin.dmg from your Downloads folder.
  • Open JDK 25.pkg from the installer image.
  • Complete the macOS installer with administrator approval.
  • Return to the macOS Terminal from earlier.

ⓧ Command not found

The installer asks for administrator approval because it adds the JDK to the system Java directory. This gives both macOS Terminal and IntelliJ IDEA access to Java 25.

  • Download the official Apple Silicon JDK installer.
  • Open jdk-25_macos-aarch64_bin.dmg from your Downloads folder.
  • Open JDK 25.pkg from the installer image.
  • Complete the macOS installer with administrator approval.
  • Return to the macOS Terminal from earlier.
  • Verify the default Java runtime again by running:
java -version

What should you see?

The version output should now identify Java 25.0.4.1. This confirms macOS Terminal can find the installed runtime.

Still seeing an older Java version?

  • Close the current Terminal window to discard its old environment.
  • Open a fresh Terminal window through Spotlight.
  • Run the version check again.

Ask for help if the older version remains selected: Why does macOS Terminal still use my older Java version?

  • Verify that the complete Java 25 compiler is installed by running:
/usr/libexec/java_home -v 25 --exec javac -version

What does this compiler check prove?

The command asks macOS to locate Java 25 before running its javac compiler. An output of javac 25.0.4.1 proves the full JDK is installed.

Cannot find the Java 25 compiler?

  • Confirm the macOS installer completed without being cancelled.
  • Check that /Library/Java/JavaVirtualMachines/jdk-25.jdk exists on your Mac.
  • Reopen the Oracle installer if that directory is missing.

Get targeted help with the compiler check: Why can java_home not find my Java 25 compiler?

That confirms the system layer is ready. Your Mac now has the Java 25 runtime plus the compiler needed for development.

Create the Java 25 project

A project SDK tells IntelliJ IDEA which JDK compiles the project. The native IntelliJ build system keeps this environment check focused on the IDE and Java.

  • Select New Project from the IntelliJ IDEA welcome screen.
  • Select Java as the project language.
  • Enter MyProject as the project name.
  • Set the project location to ~/MyProject.
  • Select IntelliJ as the build system.
  • Select JDK 25 from the JDK list.
  • Clear Add sample code.
  • Click Create.

You will see MyProject open in IntelliJ IDEA. Its Project tool window includes a src source folder.

Why use the IntelliJ build system?

The native build system gives this smoke-test project a direct link to its selected JDK. This keeps the setup focused on Java 25 while later Hyperskill content can still use Gradle when required.

  • Control-click the MyProject root in the Project tool window.
  • Select New.
  • Select File.
  • Type README.md as the file name.
  • Press Enter to create the file.
  • Replace the empty file with the following content:
# IntelliJ IDEA and Hyperskill Setup

This project verifies Java 25, IntelliJ IDEA, the `idea` launcher, and Hyperskill.

What does this file do?

  • The heading names the purpose of MyProject.
  • The description records the four parts this workspace verifies.
  • Press Cmd+S to invoke Save All.
  • Look at the Project tool window to verify the file location.

You will see README.md directly under the MyProject root.

Is README.md inside src?

Move README.md to the MyProject root if it appears under src. The file must sit beside the source folder.

Get help correcting the file location: How do I move README.md to my IntelliJ project root?

  • Select the src folder in the Project tool window.
  • Press Cmd+N to open the New menu.
  • Select Java Class.
  • Type HelloWorld as the class name.
  • Press Enter to create the class.
  • Select all generated code in HelloWorld.java.
  • Replace the selection with the following code:
public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}

What does this code do?

  • The HelloWorld class matches the file name required by Java.
  • The main(String[] args) method provides the program entry point.
  • The System.out.println("Hello World"); line sends the sample message to standard output.
  • Press Cmd+S to invoke Save All.
  • Expand src in the Project tool window.

You will see HelloWorld.java under src.

Cannot create the Java class?

  • Confirm you selected the src source folder before opening the New menu.
  • Confirm the project uses JDK 25.
  • Confirm the class name is exactly HelloWorld.

Ask for help if the Java class option remains unavailable: Why is Java Class missing from IntelliJ IDEA's New menu?

✔️ Awesome, I've got everything!

Your two project files are in place. Make sure IntelliJ IDEA has saved both files.

ⓧ I'd like to double check the full code

# IntelliJ IDEA and Hyperskill Setup

This project verifies Java 25, IntelliJ IDEA, the `idea` launcher, and Hyperskill.

public class HelloWorld {
    public static void main(String[] args) {
        System.out.println("Hello World");
    }
}
  • Click Terminal in IntelliJ IDEA's bottom tool window bar.
  • Predict whether this fresh built-in Terminal resolves Java 25 before running the check below.
  • Check the Java version used by the built-in Terminal by running:
java -version

What does the built-in Terminal confirm?

A fresh built-in Terminal receives the project JDK in its environment. You should see Java 25.0.4.1 in the version output.

  • Switch back to the macOS Terminal from earlier.
  • Predict whether macOS can still find the Java 25 compiler before running the final check.
  • Run the compiler verification again:
/usr/libexec/java_home -v 25 --exec javac -version

What should the final checks show?

The IntelliJ IDEA Terminal should identify Java 25.0.4.1. The macOS Terminal should report javac 25.0.4.1.

Together, these results prove the project SDK and system JDK point to the required Java 25 installation.

Do the two terminals report different versions?

  • Confirm MyProject uses JDK 25 in its project SDK configuration.
  • Close the current built-in Terminal session.
  • Start a fresh built-in Terminal session before repeating the check.

Get help aligning the two environments: Why do IntelliJ IDEA Terminal and macOS Terminal report different Java versions?

You have verified the complete Java 25 setup. IntelliJ IDEA now has an open project with the exact files needed for the launcher tests.

Your Java 25 workspace is ready. Next, you will create the idea launcher and test a file-only LightEdit session.

Create and Test the idea Launcher

Your Java project already opens as a complete workspace in IntelliJ IDEA. Now you need a reliable path from macOS Terminal into the same editor.

A launcher can appear to work as soon as one file opens. This step tests that shortcut so you can see whether a file-only session keeps the project features you rely on.

In this step, get ready to:
  • Make the idea launcher available on your shell's PATH.
  • Open macOS Terminal at ~/MyProject through Finder.
  • Test file-only opening with README.md.
Choose your launcher path

The launcher setup depends on how IntelliJ IDEA was installed. A standalone installation creates its launcher from the IDE.

Toolbox App manages the shell script automatically. Use the path that matches your installation.

  • Choose the tab that matches your IntelliJ IDEA installation:

Standalone installation

  • Switch back to IntelliJ IDEA.
  • Click Tools in the top menu bar.
  • Select Create Command Line Launcher….
  • Keep idea as the launcher name.
  • Confirm the dialog to create the launcher.

The launcher configuration is complete. The file-opening test below confirms whether your shell can find it.

Toolbox App installation

Toolbox App generates a shell script for each managed IntelliJ IDEA installation. It places the script directory on your shell's PATH by default.

  • Use the launcher that Toolbox App already generated.
  • Test its default idea name in the final substep.
Open Terminal at the project root

Finder can start a Terminal window inside a selected folder. This gives the launcher direct access to the existing README.md file.

  • Click Finder in the Dock.
  • Select your home folder in Finder's sidebar.
  • Open the MyProject folder.
  • Show Finder's path bar if it is hidden.
  • Control-click MyProject in the path bar.
  • Select Open in Terminal.

You'll see a macOS Terminal window rooted at ~/MyProject. That starting location lets the launcher find README.md by name.

Test a file-only launch

The -e option targets one file. The window that follows reveals how much project context IntelliJ IDEA loads for that file.

  • Before you run this command, predict whether opening only README.md gives IntelliJ IDEA the complete MyProject model.
  • Test the file-only launcher by running this command:
idea -e README.md

What does this command prove?

  • The idea command sends the file-opening request to IntelliJ IDEA.
  • The -e option opens README.md in LightEdit.
  • LightEdit loads the file without loading the complete project model.
  • Inspect the IntelliJ IDEA window opened by the command.
  • Look for the complete MyProject tree in the Project tool window.

You'll see README.md open in LightEdit. The full MyProject tree is absent.

Project-aware code completion is unavailable. Project navigation is unavailable too.

That shortfall is useful: you have proved the launcher works while exposing the boundary of a file-only editing session.

Launcher does not open README.md?

  • Repeat the matching launcher setup path above if Terminal cannot find idea.
  • Repeat the Finder path-bar steps if the launcher cannot find README.md.
  • For a Toolbox-managed installation, verify that its Shell script name field contains idea.

Help me troubleshoot the IntelliJ IDEA command-line launcher on macOS.

Your idea launcher now works from ~/MyProject. Next, you'll use it to open the complete project workspace.

Open the Full Project from Terminal

The README.md file opened from macOS Terminal in LightEdit during the previous step. That proved the idea launcher can hand a file to IntelliJ IDEA.

LightEdit cannot load the complete Java project model. This time, the launcher receives ~/MyProject so IntelliJ IDEA can restore project-aware features.

In this step, get ready to:
  • Close the file-only LightEdit session.
  • Open ~/MyProject through the idea launcher.
  • Verify the complete project model.
Leave the file-only session

The file-only window has served its purpose. Closing it makes the full-project result easy to recognize.

  • Close the LightEdit window that contains README.md.
  • Return to the macOS Terminal window from earlier.

Your existing shell session is still available at ~/MyProject.

Restore project-aware mode

A directory argument lets IntelliJ IDEA load the project model saved in ~/MyProject. The model restores the complete workspace.

Before you run this command, predict whether IntelliJ IDEA opens another single-file view or the complete project workspace.

  • Pass the complete project directory to the launcher by running this command:
idea ~/MyProject

What does this command do?

  • The idea command invokes the launcher already available on PATH.
  • The ~/MyProject argument supplies the complete project directory as the launch target.
  • IntelliJ IDEA loads the saved project metadata from that directory.
Verify the restored workspace

A full project exposes its directory tree through the Project tool window. It also retains the configured project SDK.

  • Confirm that README.md appears at the top level of the Project tool window.
  • Expand the src folder in the Project tool window.
  • Confirm that HelloWorld.java appears inside src.
  • Click File in the top menu bar.
  • Select Project Structure.
  • Select Project under Project Settings.
  • Confirm that the project SDK uses JDK 25.

You should see README.md at the project level. You should see HelloWorld.java inside src.

The project SDK should show JDK 25. Java code completion and navigation should now be available throughout the project.

That closes the project-model gap. Your launcher now restores the complete Java workspace from Terminal.

Still Seeing a File-Only Window?

  • Compare the command you entered with the project-opening command above.
  • Confirm that its target is the ~/MyProject directory.
  • Close any remaining LightEdit window to isolate the full project window.
  • Select JDK 25 in the project settings if the SDK field is empty.

Get help restoring the full project view.

Your complete Java project now opens from Terminal. Next, you will prove that JDK 25 works across both run paths.

Run Java 25 End to End

Your full ~/MyProject workspace is now open in IntelliJ IDEA. Its project model connects HelloWorld.java to the JDK 25 project SDK.

A selected SDK only matters when the same Java code executes through each path you plan to use. This step proves the editor and built-in Terminal both produce the same result.

In this step, get ready to:
  • Run HelloWorld.main() from the IntelliJ IDEA editor.
  • Execute HelloWorld.java through Java source-file mode in Terminal.
Run HelloWorld in IntelliJ IDEA

The editor gutter action runs the selected entry point with the project SDK. This checks the Java configuration attached to the complete project.

  • Double-click HelloWorld.java under src in the Project tool window.
  • Click the gutter action beside main(String[] args).

Before you run it, what output do you expect from HelloWorld.main()?

  • Select Run 'HelloWorld.main()'.

You'll see Hello World in the Run tool window. You'll also see exit code 0.

That is your first end-to-end proof. IntelliJ IDEA can execute the project with its JDK 25 SDK.

Run Action Missing?

  • Confirm that HelloWorld.java is inside src in the Project tool window.
  • Check that the method signature matches public static void main(String[] args).
  • Return to Project Structure to confirm that the project SDK is JDK 25.

Help me restore the missing IntelliJ IDEA run action.

Run the same source in Terminal

Java source-file mode executes HelloWorld.java directly through the JDK. A fresh built-in Terminal receives the project JDK on its PATH.

  • Right-click HelloWorld.java in the Project tool window.
  • Choose Open in from the context menu.
  • Select Terminal.

The fresh Terminal session starts in ~/MyProject/src. The source file is available from that directory.

Before you run it, do you expect source-file mode to match the editor run?

  • Execute HelloWorld.java through source-file mode by running this command:
java HelloWorld.java

What Does This Command Do?

  • The java command starts the JDK launcher available in the fresh terminal session.
  • The HelloWorld.java argument selects the source file in the current src directory.
  • Source-file mode runs the program without a separate compiler command.

You'll see Hello World. The prompt returns after the program exits successfully.

The editor run now matches the Terminal run. Your Java 25 setup works end to end.

Terminal Run Not Working?

  • Check that the Terminal session is in ~/MyProject/src.
  • Confirm that the file name is exactly HelloWorld.java.
  • Start a fresh built-in Terminal session to load the project JDK onto PATH.

Help me debug the Java source-file run.

Your Java 25 environment now produces the same result through both execution paths. Next, you'll connect IntelliJ IDEA to Hyperskill and open supported Java learning content.

Connect IntelliJ IDEA to Hyperskill

Your IntelliJ IDEA workspace now runs the same Java 25 sample through the editor and Terminal. That proves your local JDK is ready for Java development.

Your learning workflow also needs the Hyperskill Academy plugin to authenticate your account. In this step, you will open supported Hyperskill content with the same Java 25 environment.

In this step, get ready to:
  • Install the compatible Hyperskill Academy plugin.
  • Connect your Hyperskill account to IntelliJ IDEA.
  • Align the learning project with JDK 25.
Install the compatible Hyperskill plugin

The plugin connects IntelliJ IDEA to supported Hyperskill projects and problems. Its release line must match your IntelliJ IDEA release line.

  • In IntelliJ IDEA from earlier, open Settings/Preferences from the application menu.
  • Select Plugins in the left sidebar.
  • Select Marketplace.
  • Enter Hyperskill in the search field.
  • Select Hyperskill Academy from the results.
  • Confirm that the compatible version is 2026.20-2026.2.
  • Click Install.
  • Complete the restart if IntelliJ IDEA prompts you.

You will see Hyperskill Academy marked as installed. The plugin is now ready to connect your account.

Why This Plugin Version?

Version 2026.20-2026.2 supports IntelliJ IDEA 2026.2.3. The version suffix identifies the matching IntelliJ IDEA release line.

Cannot Install the Plugin?

  • Search for Hyperskill to find the canonical Hyperskill Academy result.
  • Confirm that IntelliJ IDEA still reports version 2026.2.3 in the About dialog.
  • Retry the installation after confirming that your Mac has an active internet connection.

Get help with the Hyperskill Academy plugin installation.

Authorize your Hyperskill account

Account authorization happens through your browser. You do not paste your Hyperskill credentials into the project.

Expect IntelliJ IDEA to hand the sign-in flow to your browser. Once you approve access, control returns to the plugin.

  • Return to Settings/Preferences in IntelliJ IDEA.
  • Select Tools in the left sidebar.
  • Select Hyperskill.
  • Click Log in.
  • Complete the browser authorization with your existing Hyperskill account.
  • Return to IntelliJ IDEA after authorization finishes.
  • Choose one supported Java project or problem from your signed-in Hyperskill content.

Your selected Hyperskill Java content opens in IntelliJ IDEA. Your learning account is now connected to the IDE.

Content Did Not Open?

  • Return to the Hyperskill settings page to confirm that your account is signed in.
  • Repeat the browser authorization if the previous browser window was closed before approval.
  • Choose content that supports opening in IntelliJ IDEA.

Get help with Hyperskill authorization.

Set JDK 25 for the learning content

Each opened learning project has its own project SDK selection. Setting JDK 25 here keeps the Hyperskill content aligned with the Java environment you already verified.

  • Click File in the IntelliJ IDEA menu bar.
  • Select Project Structure.
  • Select Project under Project Settings.
  • Select the JDK 25 installation as the project SDK.
  • Save the project SDK selection.

The Hyperskill content now shows JDK 25 as its project SDK. This selection controls the Java tools available to the project.

When Gradle Has Its Own JVM

A Gradle project also uses a Gradle JVM to import the project and execute Gradle tasks. Content without Gradle only needs the project SDK selection above.

  • Return to Settings/Preferences if the opened content uses Gradle.
  • Select Build, Execution, Deployment.
  • Select Build Tools.
  • Select Gradle.
  • Set Gradle JVM to the JDK 25 project SDK.
  • Save the Gradle JVM selection.

A fresh built-in Terminal session receives the selected project JDK through its environment. Existing sessions can retain the earlier Java path.

  • Start a fresh built-in Terminal session for the open Hyperskill content.

Before you run the final check, which Java version do you expect the fresh Terminal session to report?

  • Verify the Java version in the fresh session by running this command:
java -version

What Does This Check Prove?

The java -version command reports the default Java available to the fresh built-in Terminal session.

A Java 25 result confirms that IntelliJ IDEA added the project JDK to the new Terminal environment.

You will see a Java 25 version line. The installed target for this setup is 25.0.4.1.

Fresh Terminal Shows Another Java Version?

  • Start another fresh built-in Terminal session because older sessions retain their earlier path.
  • Return to Project Structure to reselect the JDK 25 project SDK.
  • Return to the Gradle settings to reselect the project SDK if Gradle tasks use another Java version.

Get help aligning the Hyperskill project with Java 25.

You now have supported Hyperskill Java content open with JDK 25 available to the project and its fresh Terminal sessions. Your IntelliJ IDEA learning workflow is ready.

Secret mission

Make Terminal Wait for LightEdit

Keep a Terminal command attached to a LightEdit file until you close it. You will use --wait to turn the file's closing moment into the shell's completion signal.

Clean Up Your Resources

Clean Up Your Resources

Everything you configured lives locally on your Mac through IntelliJ IDEA. There are no cloud resources or ongoing charges.

Decide whether to keep your resources running, pause them to come back later, or delete them entirely.

Resources you used:

  • The local ~/MyProject directory.
  • The Hyperskill Academy plugin version 2026.20-2026.2 installed in IntelliJ IDEA.

Keep everything running

No action needed. Choose this if you want to continue using your Java workspace for Hyperskill projects.

  • Keep the ~/MyProject directory on your Mac.
  • Leave the Hyperskill Academy plugin installed in IntelliJ IDEA.
  • Retain Oracle JDK version 25.0.4.1 for future Java projects.
  • Retain the idea launcher for opening IntelliJ IDEA from Terminal.

Pause - I'll come back to this later

Close your development tools to clear your screen while preserving the complete local setup.

  • Save any open work in IntelliJ IDEA.
  • Close IntelliJ IDEA.
  • Close macOS Terminal.

Your local setup stays ready for the next session. No charges accumulate while the applications are closed.

Delete - I don't want to use this again

Remove the project directory and the Hyperskill Academy plugin to clean up the resources created for this project.

Deleting the project directory is permanent. Choose this option only when you no longer need the project.

  • Return to IntelliJ IDEA.
  • Open Settings/Preferences.
  • Select Plugins.
  • Select the Installed tab.
  • Select Hyperskill Academy.
  • Use the uninstall control for Hyperskill Academy.

You will no longer see Hyperskill Academy in the Installed list.

  • Close IntelliJ IDEA.
  • Return to macOS Terminal.
  • Move to your home directory and delete ~/MyProject by running these commands:
cd ~
rm -rf ~/MyProject

The rm -rf command removes the project directory and every file inside it. Your Terminal prompt returns when the deletion finishes.

This cleanup leaves the idea launcher in place. Oracle JDK version 25.0.4.1 also remains available for other Java projects.

Nice Work!

Nice Work!

You did it! Your Mac now has a verified IntelliJ IDEA workspace for Java 25 development.

You've learned how to:

  • Prove your JDK 25 toolchain by running Hello World from IntelliJ IDEA and its built-in Terminal.
  • Use the idea launcher to compare file-only LightEdit with the full ~/MyProject project model.
  • Use the authenticated Hyperskill Academy plugin to open supported Java content under JDK 25.
  • Secret Mission: Use --wait to keep the shell waiting on a LightEdit file until it closes.

Ready to quiz yourself?