How To Install IntelliJ IDEA on Rocky Linux 10
IntelliJ IDEA stands as the premier integrated development environment (IDE) for Java development, created by JetBrains to empower developers with intelligent coding assistance and comprehensive tooling. Rocky Linux 10, an enterprise-grade Linux distribution that provides binary compatibility with Red Hat Enterprise Linux, offers the perfect foundation for running this powerful IDE. This guide walks through multiple installation methods, configuration steps, and optimization techniques to get IntelliJ IDEA running smoothly on Rocky Linux 10. Whether you’re a professional developer, system administrator, or student learning Java development, you’ll find detailed instructions covering prerequisites, installation, configuration, and troubleshooting to ensure a successful setup.
Prerequisites and System Requirements
Before installing IntelliJ IDEA on Rocky Linux 10, verify that your system meets the necessary hardware and software requirements.
Rocky Linux 10 Requirements
Rocky Linux 10 introduces specific hardware requirements due to its x86_64-v3 architecture baseline. Your processor must support AVX instructions, which means Intel Haswell processors (2013 or newer) or AMD Excavator processors (2015 or newer) are required. The minimum RAM allocation stands at 2 GB for graphical environments, though 4 GB or higher is recommended for optimal performance when running development tools. Disk space requirements include a minimum of 20 GB, with 40 GB or more recommended when using GUI applications and development environments. Network connectivity is essential for downloading packages and accessing repositories.
IntelliJ IDEA Requirements
IntelliJ IDEA demands at least 2 GB of RAM, but 8 GB is strongly recommended for professional development work. The IDE requires 3.5 GB of disk space at minimum, with 5 GB recommended, preferably on a solid-state drive for faster indexing and project loading. Screen resolution should be at least 1024×768, though 1920×1080 provides a better development experience. IntelliJ IDEA supports JDK versions from 7 to 21, giving you flexibility in choosing your development environment. Linux systems must have glibc 2.28 or higher installed.
Access Requirements
You need either a non-root sudo user account or root access to install system packages. SSH access proves useful for remote installations, while local terminal access works for direct system access. An active internet connection is required for downloading IntelliJ IDEA packages, Java Development Kit, and system updates.
Understanding IntelliJ IDEA Editions
JetBrains offers three distinct editions of IntelliJ IDEA, each designed for different use cases and licensing models.
Community Edition
The Community Edition comes free and open-source under the Apache 2 license. It provides excellent support for Java, Kotlin, Groovy, and Scala development. This edition suits students, open-source contributors, and developers working on basic Java projects. While it lacks some enterprise features, it delivers robust coding assistance, refactoring tools, and debugging capabilities for core Java development.
Ultimate Edition
The Ultimate Edition represents the commercial offering with extensive enterprise features. It includes support for Spring, Jakarta EE, Micronaut, and other enterprise frameworks. Web development tools for JavaScript, TypeScript, HTML, and CSS come integrated. Database tools with SQL support enable direct database interaction from the IDE. JetBrains offers a 30-day free trial, after which a paid license is required. Professional developers and enterprises typically choose this edition for its comprehensive toolset.
Educational Edition
Designed specifically for learning programming, the Educational Edition integrates with educational platforms. It includes features tailored for students and educators, making it ideal for academic environments and coding bootcamps.
Step 1: Updating Rocky Linux 10 System
System updates ensure you have the latest security patches and bug fixes before installing new software.
Open your terminal and run the system update command:
sudo dnf update -yThis command updates all installed packages to their latest versions. Install essential utilities that will be useful throughout the installation process:
sudo dnf install dnf-utils epel-release wget curl tar -yThe EPEL (Extra Packages for Enterprise Linux) repository provides additional packages not available in the default Rocky Linux repositories. After installing major system updates, consider rebooting your system:
sudo systemctl rebootVerify that updates installed successfully by checking the system version:
cat /etc/rocky-releaseStep 2: Installing Java Development Kit (JDK)
IntelliJ IDEA requires a Java Runtime Environment to function. The Java Development Kit includes both runtime and development tools.
Why JDK is Required
IntelliJ IDEA itself runs on Java, making JDK installation a mandatory prerequisite. Beyond running the IDE, having JDK installed enables you to compile, debug, and run Java applications directly within IntelliJ IDEA. The JDK includes the Java compiler (javac), runtime environment (JRE), and standard libraries necessary for Java development.
Installing OpenJDK
Rocky Linux repositories include OpenJDK, the open-source implementation of Java. Install OpenJDK 11, which offers long-term support:
sudo dnf install java-11-openjdk-devel -yAlternatively, install Java 17, another LTS version with modern features:
sudo dnf install java-17-openjdk-devel -yFor the latest features, install Java 21:
sudo dnf install java-21-openjdk-devel -yVerifying Java Installation
Confirm Java installed correctly by checking the version:
java -versionYou should see output displaying the OpenJDK version, runtime environment, and build information. Verify the Java compiler installation:
javac -versionCheck the Java installation path:
which javaThis typically returns /usr/bin/java or /usr/lib/jvm/ directory paths.
Configuring JAVA_HOME
Setting the JAVA_HOME environment variable helps applications locate your Java installation. Add this to your ~/.bashrc file:
echo 'export JAVA_HOME=/usr/lib/jvm/java-11-openjdk' >> ~/.bashrc
echo 'export PATH=$PATH:$JAVA_HOME/bin' >> ~/.bashrc
source ~/.bashrcVerify the JAVA_HOME variable:
echo $JAVA_HOMEStep 3: Installation Method 1 – Using Snap Package Manager
Snap provides the simplest installation method with automatic updates.
Installing Snapd on Rocky Linux 10
Ensure EPEL repository is enabled (completed in Step 1), then install snapd:
sudo dnf install snapd -yEnable and start the snapd socket:
sudo systemctl enable --now snapd.socketInstall the snap core:
sudo snap install coreCreate a symbolic link to enable classic snap support:
sudo ln -s /var/lib/snapd/snap /snapRestart your system or log out and back in to ensure snap paths are updated correctly.
Installing IntelliJ IDEA via Snap
For the Community Edition, execute:
sudo snap install intellij-idea-community --classicThe --classic flag grants IntelliJ IDEA access to system resources outside the snap sandbox, which is necessary for IDE functionality. For the Ultimate Edition:
sudo snap install intellij-idea-ultimate --classicFor the Educational Edition:
sudo snap install intellij-idea-educational --classicVerifying Snap Installation
List installed snaps to confirm installation:
sudo snap list | grep intellijCheck the installed version and revision number. View detailed snap information:
snap info intellij-idea-communityAdvantages of Snap Installation
Snap packages update automatically, ensuring you always run the latest version. The installation process remains simple and consistent across different Linux distributions. Snap’s containerized approach provides security isolation. Package management becomes straightforward with simple commands for installation, updates, and removal.
Step 4: Installation Method 2 – Manual Installation from Tarball
Manual installation provides complete control over the installation directory and version management.
Downloading IntelliJ IDEA
Visit the official JetBrains website or download directly from the terminal. For Community Edition:
cd ~/Downloads
wget https://download.jetbrains.com/idea/[version].tar.gzFor Ultimate Edition:
wget https://download.jetbrains.com/idea/[version].tar.gzReplace version numbers with the latest available. Verify download integrity by comparing file size with the official website specifications.
Extracting the Archive
Extract the downloaded tarball:
tar -xzf ideaIC-*.tar.gzThis creates a directory with the IDE files. For temporary extraction to /tmp:
tar -xzf ideaIC-*.tar.gz -C /tmp/Moving to Installation Directory
Create the installation directory in /opt:
sudo mkdir -p /opt/intellij-ideaMove the extracted files:
sudo mv idea-IC-* /opt/intellij-ideaOr rename during the move for cleaner paths:
sudo mv idea-IC-* /opt/intellij-idea-communitySet appropriate permissions:
sudo chown -R root:root /opt/intellij-idea-community
sudo chmod +x /opt/intellij-idea-community/bin/idea.shCreating Symbolic Link
Create a symbolic link for easier command-line access:
sudo ln -s /opt/intellij-idea-community/bin/idea.sh /usr/local/bin/intellij-ideaNow launch IntelliJ IDEA from anywhere by typing intellij-idea in the terminal.
Advantages of Manual Installation
Manual installation gives you complete control over installation location and directory structure. Version management becomes easier when you need specific releases or multiple versions simultaneously. No dependency on package managers means installations work identically across different distributions. Custom deployment scenarios in enterprise environments benefit from this flexibility.
Step 5: Installation Method 3 – Using Flatpak
Flatpak offers another containerized application distribution method.
Setting up Flatpak on Rocky Linux 10
Install Flatpak package manager:
sudo dnf install flatpak -yAdd the Flathub repository, which hosts IntelliJ IDEA:
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepoInstalling IntelliJ IDEA via Flatpak
For Community Edition:
flatpak install flathub com.jetbrains.IntelliJ-IDEA-CommunityAccept repository additions and dependency installations when prompted. For Ultimate Edition:
flatpak install flathub com.jetbrains.IntelliJ-IDEA-UltimateRunning Flatpak Version
Launch IntelliJ IDEA:
flatpak run com.jetbrains.IntelliJ-IDEA-CommunityFlatpak Considerations
Flatpak packages include all runtime dependencies, resulting in larger disk space usage. The sandboxed environment may limit some filesystem access. Performance can differ slightly from native installations. Choose Flatpak when you prefer containerized applications or need multiple application versions isolated from each other.
Step 6: Launching IntelliJ IDEA for the First Time
The initial launch triggers configuration wizards that customize your IDE experience.
Starting IntelliJ IDEA
From command line with snap installation:
intellij-idea-communityFrom manual installation:
/opt/intellij-idea-community/bin/idea.shOr simply:
intellij-ideaFrom the GUI, open your application menu, search for “IntelliJ IDEA,” and click the icon.
Initial Configuration Wizard
The first screen asks about importing settings. Select “Do not import settings” for fresh installations. Click OK to proceed. Accept the JetBrains Privacy Policy after reviewing the terms. Choose your data sharing preferences—these settings can be changed later.
Theme Selection
IntelliJ IDEA presents theme options including Light and Darcula (dark theme). Dark themes reduce eye strain during extended coding sessions. Light themes work better in bright environments. Select your preference; you can change themes anytime through Settings.
UI Configuration
Recent IntelliJ IDEA versions offer a New UI with modernized interface elements. The classic UI remains available for users preferring the traditional layout. The New UI provides streamlined navigation and updated visual design. Choose based on personal preference and familiarity.
Plugin Configuration
The setup wizard displays featured plugins for various development scenarios. Popular plugins include:
- Version control systems (Git, SVN)
- Build tools (Maven, Gradle)
- Framework support (Spring, Hibernate)
- Cloud platform integrations
Skip detailed plugin configuration initially. Install plugins as needed while working on projects. This approach prevents overwhelming initial setup and maintains IDE performance.
Step 7: Creating Desktop Entry and Launcher
Desktop integration provides convenient access to IntelliJ IDEA.
Automatic Desktop Entry Creation
Launch IntelliJ IDEA and navigate to Tools → Create Desktop Entry from the main menu. Choose whether to create the entry for all users or just the current user. System-wide entries require sudo privileges. The desktop entry file is created in /usr/share/applications/ for all users or ~/.local/share/applications/ for single users.
Manual Desktop Entry
If automatic creation fails, create the entry manually. Open a text editor:
sudo nano /usr/share/applications/intellij-idea.desktopAdd the following content:
[Desktop Entry]
Version=1.0
Type=Application
Name=IntelliJ IDEA Community
Icon=/opt/intellij-idea-community/bin/idea.png
Exec=/opt/intellij-idea-community/bin/idea.sh %f
Comment=Capable and Ergonomic IDE for JVM
Categories=Development;IDE;
Terminal=false
StartupWMClass=jetbrains-ideaSave and update the desktop database:
sudo update-desktop-databaseLauncher Script Setup
For convenient command-line access, ensure the symbolic link exists:
ls -la /usr/local/bin/intellij-ideaMake the script executable if needed:
sudo chmod +x /usr/local/bin/intellij-ideaStep 8: Configuring Java SDK in IntelliJ IDEA
Project SDK configuration enables IntelliJ IDEA to compile and run Java applications.
Setting up Project SDK
Open IntelliJ IDEA and navigate to File → Project Structure → Project Settings → Project. Click the Project SDK dropdown and select “Add SDK” → “JDK.” IntelliJ IDEA automatically detects installed JDKs. Select the appropriate version from the detected list.
Configuring SDK Path
If automatic detection fails, manually specify the SDK path. Common JDK locations on Rocky Linux include:
/usr/lib/jvm/java-11-openjdk/usr/lib/jvm/java-17-openjdk/usr/lib/jvm/java-21-openjdk
Browse to the correct directory and select it as your project SDK.
Setting SDK Version
Choose the SDK version matching your project requirements. IntelliJ IDEA supports JDK 7 through 21. Configure the language level separately to use newer syntax features while targeting older JVM versions. This flexibility enables modern development practices while maintaining backward compatibility.
Downloading JDK through IntelliJ
IntelliJ IDEA includes a built-in JDK downloader. In the SDK selection dialog, click “Download JDK.” Choose your preferred vendor (Oracle, OpenJDK, Amazon Corretto, Azul Zulu). Select the version and installation location. IntelliJ IDEA handles the download and configuration automatically.
Step 9: Initial Configuration and Optimization
Optimize IntelliJ IDEA for better performance on Rocky Linux 10.
Memory Allocation Optimization
IntelliJ IDEA runs on the Java Virtual Machine, which requires memory tuning for optimal performance. Locate the vmoptions file:
nano ~/.config/JetBrains/IdeaIC2024.2/idea64.vmoptionsAdjust memory settings based on available RAM:
-Xms1024m
-Xmx4096m
-XX:ReservedCodeCacheSize=512m
-XX:+UseG1GC-Xms sets initial heap size; -Xmx sets maximum heap size. For systems with 8 GB RAM, allocate 4 GB to IntelliJ IDEA. Systems with 16 GB can allocate 8 GB for large projects.
Appearance Customization
Navigate to File → Settings → Appearance & Behavior → Appearance. Adjust theme, font size, and UI scaling. Enable “Use custom font” for better readability on high-DPI displays. Configure toolbar visibility and tool window layout according to workflow preferences.
Code Style Settings
Configure File → Settings → Editor → Code Style. Set indentation preferences (spaces vs tabs, size). Configure import organization and sorting. Establish code formatting standards for consistency across projects. These settings apply to all projects unless overridden at project level.
Plugin Installation
Access File → Settings → Plugins. Browse the Marketplace for additional functionality:
- Database tools for SQL development
- Docker integration for containerized applications
- Cloud platform plugins (AWS, Azure, GCP)
- Framework-specific tools
Install only necessary plugins to maintain IDE responsiveness. Disable unused plugins through the Installed tab.
Keymap Configuration
Navigate to File → Settings → Keymap. Select predefined keymaps (Eclipse, VS Code, NetBeans) if migrating from another IDE. Customize individual shortcuts for frequently used actions. Export keymap settings for backup and consistency across installations.
Step 10: Creating Your First Project
Test your IntelliJ IDEA installation by creating a simple Java project.
New Project Creation
Click “New Project” on the welcome screen. Select project type—Java for basic applications, Maven or Gradle for build-managed projects. Name your project and choose the storage location. Ensure the location has sufficient space and appropriate permissions.
Project SDK Selection
Select the JDK configured earlier from the Project SDK dropdown. Choose the language level appropriate for your target platform. Higher language levels enable newer Java features but may limit compatibility with older JVM versions.
Build System Configuration
IntelliJ native build system works well for simple projects. Maven provides dependency management and standardized project structure. Gradle offers flexible build configuration with Groovy or Kotlin DSL. Choose based on project complexity and team preferences.
Testing Installation with Hello World
Create a new Java class in the src directory:
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Rocky Linux 10!");
}
}Click the green play button or press Shift+F10 to run. The console displays output, confirming successful installation and configuration.
Troubleshooting Common Issues
Address common problems encountered when running IntelliJ IDEA on Rocky Linux 10.
IntelliJ IDEA Won’t Launch
Missing library errors, particularly libjli.so, indicate Java configuration problems. Verify Java installation:
java -version
which javaInstall missing dependencies:
sudo dnf install java-11-openjdk-devel -yCheck that JAVA_HOME environment variable points to a valid JDK installation. Examine error logs in ~/.config/JetBrains/IdeaIC2024.2/log/ for specific failure reasons.
Performance Issues and Freezing
Insufficient memory allocation causes IDE freezes and slow performance. Increase heap size in idea64.vmoptions as described earlier. Disable unnecessary plugins that consume resources. Clear caches by selecting File → Invalidate Caches / Restart. This resolves indexing corruption and stale data issues.
Monitor system resources with htop or top while running IntelliJ IDEA. Ensure adequate free RAM and CPU availability. Close resource-intensive applications running simultaneously.
Snap Permission Issues
Snap confinement restrictions can limit filesystem access. The --classic flag during installation grants necessary permissions. If file access problems persist, verify snap connections:
snap connections intellij-idea-communityGrant additional permissions if needed for specific interfaces.
Display Issues
High-DPI displays may render incorrectly without proper scaling. Set environment variables before launching:
export GDK_SCALE=2
export GDK_DPI_SCALE=0.5Font rendering issues on Linux systems often relate to font configurations. Install additional font packages:
sudo dnf install fontconfig liberation-fonts -yWayland compositor users experiencing problems should try running under X11 instead.
Java Version Conflicts
Multiple JDK installations can cause version conflicts. Use the alternatives command to manage default Java version:
sudo alternatives --config javaSelect the appropriate version from the list. Verify IntelliJ IDEA uses the correct JDK in Project Structure settings.
Lock File Issues
IDE crashes leave lock files preventing subsequent launches. Delete lock files manually:
rm ~/.config/JetBrains/IdeaIC2024.2/port.lock
rm ~/.config/JetBrains/IdeaIC2024.2/.lockRestart IntelliJ IDEA after removing lock files.
Managing and Updating IntelliJ IDEA
Keep your IDE current with regular updates for bug fixes and new features.
Updating Snap Version
Snap packages update automatically by default. Check current version:
snap list intellij-idea-communityManually trigger updates:
sudo snap refresh intellij-idea-communityView update history:
snap changesUpdating Manual Installation
Download the latest version from the JetBrains website. Back up your existing installation:
sudo cp -r /opt/intellij-idea-community /opt/intellij-idea-community.backupExtract the new version and replace the old directory:
sudo rm -rf /opt/intellij-idea-community
sudo tar -xzf ideaIC-*.tar.gz -C /opt/
sudo mv /opt/idea-IC-* /opt/intellij-idea-communitySettings and plugins persist in your home directory, preserving customizations across updates.
Built-in Update Feature
IntelliJ IDEA includes update checking. Navigate to Help → Check for Updates. The IDE displays available updates with release notes. Choose to download and install or postpone updates. Select update channels (Stable, Beta, Early Access Program) in Settings → Appearance & Behavior → System Settings → Updates.
Uninstalling IntelliJ IDEA
Remove IntelliJ IDEA when no longer needed or before clean reinstallation.
Removing Snap Installation
Execute the removal command:
sudo snap remove intellij-idea-communityThis removes the application and frees disk space. User configurations remain in the home directory unless purged separately:
rm -rf ~/.config/JetBrains/IdeaIC*Removing Manual Installation
Delete the installation directory:
sudo rm -rf /opt/intellij-idea-communityRemove symbolic links:
sudo rm /usr/local/bin/intellij-ideaDelete desktop entries:
sudo rm /usr/share/applications/intellij-idea.desktopClean configuration directories:
rm -rf ~/.config/JetBrains/IdeaIC*
rm -rf ~/.cache/JetBrains/IdeaIC*
rm -rf ~/.local/share/JetBrains/IdeaIC*Best Practices and Tips
Maximize productivity with these IntelliJ IDEA best practices.
Regular Backups
Export settings regularly through File → Manage IDE Settings → Export Settings. Save the exported JAR file to cloud storage or external drives. Export includes keymaps, code styles, live templates, and IDE preferences. Import these settings on new installations for consistent environments across machines.
Version Control Integration
Configure Git integration in File → Settings → Version Control → Git. Specify the Git executable path if not automatically detected. Set up SSH keys for remote repository access:
ssh-keygen -t ed25519 -C "your_email@example.com"
cat ~/.ssh/id_ed25519.pubAdd the public key to GitHub, GitLab, or Bitbucket account settings.
Performance Tips
Store projects on SSD drives for faster indexing and file operations. Exclude build directories from indexing in File → Settings → Project Structure. Disable plugins not actively used for reduced memory consumption. Increase file watcher limit on Linux systems:
echo "fs.inotify.max_user_watches = 524288" | sudo tee -a /etc/sysctl.conf
sudo sysctl -pSecurity Considerations
Run IntelliJ IDEA as a non-root user for system security. Keep the IDE updated to receive security patches promptly. Review plugin permissions before installation, avoiding untrusted sources. Use encrypted connections for remote development and database access.
Congratulations! You have successfully installed IntelliJ IDEA. Thanks for using this tutorial for installing IntelliJ IDEA on your Rocky Linux 10 system. For additional help or useful information, we recommend you check the official Jetbrains website.
