← Back to DevBytes
Developer Tutorial July 12, 2026 15 min read

IntelliJ IDEA Themes and Customization: Complete Guide

What Are IntelliJ IDEA Themes?

IntelliJ IDEA themes are collections of visual settings that control the entire look and feel of the IDE. A theme encompasses the UI theme (the chrome around your editor — toolbars, menus, sidebars, and dialog boxes) and the editor color scheme (the syntax highlighting colors for code, backgrounds, gutters, and inline elements). Together they create a cohesive visual environment where you spend hours every day writing and debugging code.

JetBrains ships IntelliJ IDEA with several built-in themes. The classic IntelliJ Light theme has been the default for years, while Darcula offers a dark alternative that many developers prefer for late-night coding sessions. More recent releases introduced High Contrast for accessibility needs and the sleek Dark Purple theme. Each of these is carefully designed to balance readability, aesthetics, and functional clarity across the entire IDE surface.

Under the hood, an IntelliJ theme is defined through a combination of .theme.json files (for UI theming) and .icls or XML-based color scheme files (for editor syntax coloring). Understanding this separation is key to effective customization — changing your editor colors does not automatically update your UI chrome, and vice versa.

Why Theme Customization Matters

🚀 Deploy your AI agent in 10 minutes

Managed Hermes hosting. Zero DevOps. 100M tokens/mo included.

Try it free →

Developers spend an extraordinary amount of time inside their IDE — often 6 to 10 hours a day. The visual environment directly impacts comfort, focus, and even physical health. Here is why investing time in theme customization pays dividends:

Eye Strain and Fatigue Reduction

A poorly chosen color scheme with high-contrast backgrounds or jarring syntax colors can cause eye fatigue within hours. Dark themes reduce overall luminance, which many developers find gentler during extended sessions, especially in low-light rooms. Carefully tuned contrast ratios — not too harsh, not too washed-out — keep your eyes comfortable through long debugging marathons.

Code Comprehension and Scanning Speed

Syntax highlighting is not merely decorative. When keywords, strings, method calls, and type annotations are colored distinctly and consistently, your brain learns to parse code structure almost pre-attentively. You scan a file and instantly spot method boundaries, string literals, or error-state lines. A well-designed color scheme makes code semantics visually obvious, reducing the cognitive load of reading complex logic.

Personal Comfort and Ownership

Customizing your IDE makes it feel like your tool. The psychological effect of working in an environment tailored to your preferences is real — it increases satisfaction and can subtly boost motivation. Whether you prefer a minimalist monochrome palette or a vibrant rainbow of semantic tokens, the IDE should reflect how your brain best processes information.

Accessibility Needs

For developers with visual impairments, color blindness, or neurological sensitivities, theme customization moves from preference to necessity. High-contrast modes, carefully chosen hues that remain distinguishable under various forms of color blindness, and adjustable font scaling all contribute to making IntelliJ IDEA accessible to every developer.

Built-in Themes: The Starting Point

Before diving into custom themes, familiarize yourself with what ships out of the box. Open Settings / Preferences (Ctrl+Alt+S on Windows/Linux, Cmd+, on macOS) and navigate to Appearance & Behavior > Appearance. Here you see the Theme dropdown:

Switching between these is instant — no restart required. Try each for a day to discover which baseline resonates with your eyes. Note that the editor color scheme is a separate setting under Editor > Color Scheme, where you can independently choose schemes like "Darcula," "Monokai," "Solarized Light," or "GitHub Light."

Installing Custom Themes from the Plugin Marketplace

The IntelliJ plugin ecosystem hosts dozens of high-quality third-party themes. These are the fastest way to radically transform your IDE's appearance without manual configuration. Here is the complete workflow:

Step 1: Open the Marketplace

Go to Settings > Plugins (Ctrl+Alt+S then navigate to Plugins). Click the Marketplace tab and search for "theme." Popular options include:

Step 2: Install and Apply

Click Install on your chosen theme plugin, then restart the IDE when prompted. After restart, go to Settings > Appearance & Behavior > Appearance. The new theme now appears in the Theme dropdown. Select it. Some plugins (like Material Theme UI) also install companion editor color schemes — check Editor > Color Scheme to select the matching scheme.

Step 3: Fine-Tune Plugin Themes

Many theme plugins expose their own settings panel. For Material Theme UI, look for Material Theme in the Settings tree. There you can adjust accent colors, contrast levels, tab highlighting styles, and even enable "Compact" mode for denser UI layouts. Explore these panels — the plugin author often provides granularity that the base IDE does not expose.

Creating Your Own Custom Theme from Scratch

For ultimate control, you can build a personal theme. IntelliJ IDEA uses the Theme plugin format for UI theming and Color Scheme XML files for editor syntax colors. Let's walk through both.

Custom UI Theme via Plugin

A UI theme plugin is a standard IntelliJ platform plugin that provides a .theme.json file. The recommended approach is to use the IntelliJ Plugin Generator or create the project manually. Here is a minimal example structure:

my-custom-theme/
├── META-INF/
│   └── plugin.xml
├── resources/
│   └── my_custom_theme.theme.json
└── src/  (optional, for extensions)

The plugin.xml registers your theme with the IDE:

<idea-plugin>
  <id>com.example.my-custom-theme</id>
  <name>My Custom Theme</name>
  <vendor>YourName</vendor>

  <extensions defaultExtensionNs="com.intellij">
    <themeProvider
      id="my_custom_theme"
      path="resources/my_custom_theme.theme.json" />
  </extensions>
</idea-plugin>

The .theme.json file defines color mappings. IntelliJ themes reference theme keys — symbolic names for every UI element. Here is a snippet that overrides the editor background and tree selection color:

{
  "name": "My Custom Theme",
  "dark": true,
  "colors": {
    "editor.background": "#1e1e2e",
    "editor.foreground": "#cdd6f4",
    "sidePanel.background": "#181825",
    "tree.selectionBackground": "#45475a",
    "tree.selectionInactiveBackground": "#313244",
    "component.border.color": "#45475a",
    "toolbar.background": "#181825",
    "textField.background": "#313244",
    "textField.foreground": "#cdd6f4",
    "button.background": "#45475a",
    "button.foreground": "#cdd6f4",
    "button.hoverBackground": "#585b70",
    "menu.background": "#1e1e2e",
    "menu.foreground": "#cdd6f4",
    "menu.selectionBackground": "#45475a",
    "tab.selectedBackground": "#1e1e2e",
    "tab.inactiveBackground": "#181825"
  },
  "ui": {
    "window.title": {
      "font": "Inter, 13px, bold"
    }
  }
}

Build the plugin with Gradle (./gradlew build), then install it via Settings > Plugins > Install Plugin from Disk. Your theme appears in the Appearance dropdown.

Custom Editor Color Scheme

Editor color schemes are simpler to create — you can do it entirely within the IDE. Navigate to Settings > Editor > Color Scheme. Pick a built-in scheme close to your target, then click the gear icon > Duplicate to create an editable copy. Give it a descriptive name like "My Night Blue."

Now explore the expansive tree of configurable elements:

For each element, you set foreground/background colors, font styles (bold, italic, underline), and effect colors (underline waves for errors). The preview pane updates in real time. Here is a practical example: customizing Java syntax colors for a warm, low-contrast palette:

# In Color Scheme > Java
Keyword (foreground): #c4a77d (warm gold, bold)
String (foreground): #7c9c6b (muted green)
Line comment (foreground): #6a6f7a (dim grey, italic)
Block comment (foreground): #5a5f6a (dimmer grey)
Method call (foreground): #b09f7a (light tan)
Number (foreground): #a6876b (warm brown)
Annotation (foreground): #c48b6d (rust, bold italic)
Error (foreground): #d4756b (soft red, underline wave)

To share this scheme, use gear icon > Export > Color Scheme XML. The resulting .icls file is portable and can be imported by colleagues via Import Scheme.

Font Configuration for Optimal Readability

Typography is a cornerstone of IDE comfort. IntelliJ IDEA provides extensive font controls split between the UI and the editor. Access these at Settings > Appearance & Behavior > Appearance for UI fonts, and Settings > Editor > Font for editor text.

Choosing an Editor Font

Modern developers gravitate toward monospaced fonts designed for code. The built-in JetBrains Mono is outstanding — it includes coding ligatures, distinct character shapes (zero vs. capital O, one vs. lowercase L), and excellent readability at small sizes. Alternatives beloved by the community include:

Ligatures: Love Them or Leave Them

Ligatures transform multi-character sequences like !=, =>, or === into single typographic glyphs. They look beautiful but some developers find them confusing during cursor navigation. Toggle them at Editor > Font > Enable font ligatures. JetBrains Mono offers both ligature and non-ligature variants — install the one that matches your preference.

Font Sizing and Line Height

A practical configuration for a 14-inch laptop screen:

Editor Font: JetBrains Mono
Size: 14px
Line height: 1.3 (slightly more breathing room than default 1.2)
UI Font: Inter, 12px (for compact tool windows)

For high-DPI 4K displays, try size 16–18px. Remember that Ctrl+Shift+A > Change font size with Ctrl+Mouse Wheel lets you adjust on the fly — enable this if you frequently switch between standing/sitting desk setups or share your screen during code reviews.

Customizing IDE-Wide UI Elements

Beyond themes and fonts, IntelliJ IDEA exposes dozens of UI tweaks that compound into a highly personalized workspace. These live under Settings > Appearance & Behavior > Appearance and various sub-panels.

Icon Set and Tool Windows

Under Appearance, you can switch the Icon set between "IntelliJ" and "New UI." The New UI icons are cleaner, more minimal, and align with the updated interface design introduced in IDEA 2023+. Also explore:

Status Bar and Breadcrumbs

The status bar at the bottom can be customized via right-clicking it. Add or remove widgets like git branch display, line/column indicator, file encoding, and inspection profile. Breadcrumbs (the navigation bar above the editor) can show file path, symbol hierarchy, or both — configure at Editor > General > Breadcrumbs.

Inlay Hints and Code Vision

Modern IntelliJ versions show inline hints for parameter names, type annotations, and code authorship (Code Vision). These are themable — go to Editor > Inlay Hints to adjust font size, background color, and which hints appear. For a distraction-free experience, consider making hints subtle: grey foreground, smaller font, no background highlight.

Exporting and Sharing Your Customization

Once you have perfected your theme, color scheme, and UI layout, you will want to preserve it and potentially share it with your team. IntelliJ IDEA offers several mechanisms.

Exporting Settings as a ZIP Archive

Go to File > Manage IDE Settings > Export Settings. This opens a wizard where you can cherry-pick which configuration categories to export — UI theme, color schemes, keymaps, code styles, and more. The result is a settings.zip file that colleagues can import via File > Manage IDE Settings > Import Settings.

Settings Repository (Team Sync)

For teams, the Settings Repository feature (under Settings > Settings Repository) lets you store IDE configurations in a Git repository. Team members subscribe to the same repository and receive updates when configurations change. This is powerful for enforcing consistent code styles and inspection profiles across an organization, but themes sync here as well. Configure it like this:

# Example: Settings Repository configuration
Repository URL: https://github.com/myteam/ide-settings.git
Auto-upload: On (pushes your changes automatically)
Auto-sync: On (pulls team changes on startup)
Merge strategy: Manual (review conflicts before applying)

Sharing Color Schemes via Plugin

If you create a particularly polished editor color scheme, consider packaging it as a plugin and publishing it on the JetBrains Marketplace. Use the IntelliJ Platform Plugin Template on GitHub, add your .icls file to the resources, and register it in plugin.xml under the com.intellij.colorScheme extension point. The community benefits from your work, and you gain the satisfaction of contributing to the ecosystem.

Advanced: Programmatic Theme Switching and Automation

Some developers switch themes based on time of day, ambient light, or context (coding vs. code review). While IntelliJ IDEA does not have a built-in scheduler for themes, you can achieve this through plugins or external scripts.

Using the "Sync with OS" Feature

On macOS, IntelliJ can sync its theme with the operating system's dark/light mode setting. Enable this at Settings > Appearance & Behavior > Appearance > Theme: Sync with OS. When macOS switches to Dark Mode at sunset (or based on your scheduled Night Shift), IntelliJ follows suit. This is the simplest automation and requires no configuration beyond a single checkbox.

Command-Line Theme Switching

For advanced users, IntelliJ stores theme selection in its configuration files. On Linux/macOS, you can script changes. The active theme is stored in options/other.xml inside the configuration directory (typically ~/.config/JetBrains/IntelliJIdea2024.1/). A script can modify the XML and trigger a settings reload, though this approach is brittle across IDE versions. A safer alternative is using the IDE scripting console (accessible via Ctrl+Shift+A > Scripting Console) where you can write Groovy scripts that interact with the IDE's internal APIs.

Here is an example Groovy snippet to toggle between two themes programmatically (run via the IDE scripting console or a plugin):

import com.intellij.ide.ui.LafManager
import com.intellij.ide.ui.UIManager

def lafManager = LafManager.getInstance()
def currentTheme = lafManager.lookAndFeelReference

if (currentTheme.name.contains("Darcula")) {
  // Switch to Light theme
  lafManager.setLookAndFeel(
    LafManager.LIGHT_THEME_KEY,
    true
  )
} else {
  // Switch to Darcula
  lafManager.setLookAndFeel(
    LafManager.DARK_THEME_KEY,
    true
  )
}

// Notify UI to refresh
UIManager.getInstance().updateUI()

This script demonstrates the power of IntelliJ's internal API. However, for production use, rely on the Sync with OS feature or a dedicated scheduling plugin from the marketplace rather than maintaining custom scripts.

Best Practices for Theme Customization

After years of watching developers tweak their IDEs, several patterns emerge that lead to sustainable, comfortable setups. Here are distilled best practices:

1. Start with a Solid Foundation

Begin customization from a built-in theme that is already 80% of what you want. Radical overhauls from scratch often introduce inconsistency — a button that is invisible on hover, a tooltip with unreadable text. The built-in themes have been tested across thousands of UI surfaces. Duplicate and tweak rather than burn down and rebuild.

2. Prioritize Contrast, Not Saturation

A common mistake is cranking up color saturation to make syntax "pop." This backfires — highly saturated adjacent colors create visual vibration and fatigue. Instead, prioritize contrast ratios. Text against background should maintain at least a 4.5:1 ratio for body text (per WCAG AA guidelines). Use muted, earthy syntax colors that are distinct in hue but restrained in saturation. Your eyes will thank you after hour six.

3. Maintain Semantic Consistency

Respect the "vocabulary" of syntax highlighting. Comments should be consistently grey or muted across all languages. Errors should be consistently red-ish. Warnings should be yellow-ish. When you flip these conventions (making comments bright green, for example), you force your brain to re-learn parsing cues every time you switch languages or files. The IntelliJ color scheme hierarchy lets you set Language Defaults that cascade to all languages — use this to enforce consistency.

4. Document Your Customizations

When you export your settings ZIP, include a README.md that explains your color choices, font selections, and any non-obvious tweaks. If you are sharing with a team, this documentation prevents "why is my IDE pink?" confusion. For personal use, it helps you reconstruct your setup on a new machine without guesswork.

5. Version Control Your IDE Settings

Treat your IDE configuration like code. Use the Settings Repository feature (described above) or simply commit your exported settings.zip to a personal dotfiles repository. Tag versions — "v1.2 warm-palette" — so you can roll back if a change does not work out after a week of use.

6. Iterate Slowly

Change one thing at a time and live with it for a few days before changing something else. Changing your font, color scheme, UI theme, and keymap all in one afternoon is overwhelming and makes it impossible to isolate what is actually improving or degrading your experience. Small, deliberate iterations lead to a finely tuned environment that feels invisible — the highest compliment for an IDE setup.

7. Consider Your Environment

Your physical workspace dictates ideal theme parameters. In a brightly lit office with large windows, a light theme may actually reduce glare compared to a dark theme (which forces your pupils to dilate, making screen reflections more noticeable). In a dim home office at midnight, a dark theme is objectively easier on the eyes. If you work in both contexts, configure two profiles and switch between them — or use the Sync with OS feature on macOS to automate the transition.

8. Test with Real Codebases

A theme that looks stunning on a 20-line sample file may fall apart on a 500-line production class with generics, annotations, lambdas, and inline documentation. Always validate your color scheme against a dense, real-world codebase from your actual project. Look for edge cases: nested generic types, multi-line lambdas, injected SQL strings, diff views, and debugger highlights. The best themes hold up under complexity.

Conclusion

IntelliJ IDEA's theming system is remarkably deep — from one-click marketplace plugins to hand-crafted .theme.json definitions and pixel-perfect editor color schemes. Investing time in customization is not vanity; it is an investment in your daily comfort, code comprehension speed, and long-term eye health. Start by exploring the built-in themes and the rich plugin marketplace. Duplicate a scheme that resonates, then iterate slowly on colors, fonts, and UI density. Export your work, version-control it, and share it with your team if it helps others. A well-configured IDE fades into the background of your attention, letting you focus entirely on the code — and that is exactly where you want to be.

🚀 Need a reliable AI agent for your project?

Deploy Hermes Agent in 10 minutes. Managed hosting, zero DevOps.

Get Started — $23.99/mo
← Back to all articles