JetBrains IDE caches on Mac: IntelliJ, PyCharm, WebStorm and old versions

JetBrains caches on a Mac live in ~/Library/Caches/JetBrains, in one folder for each IDE and each version you've run: IntelliJIdea2026.2, PyCharm2026.2, WebStorm2026.2 and so on. Each holds that version's indexes, caches and Local History, and next to it sit separate folders for its settings, plugins and logs.

On a Mac that has run these IDEs for a while, much of that space belongs to versions you no longer use. Every new release of an IDE starts a fresh set of folders, and the old sets stay behind until the IDE removes them or you do.

Most of it can go. The IDE rebuilds indexes and caches by itself, and it has its own command for removing old versions' folders: Help › Delete Leftover IDE Directories. What you give up is time, while the IDE indexes your projects again, and the Local History of the folders you remove.

This post goes through each folder, what removing it costs, how Invalidate Caches differs from cleaning up, and how the Toolbox App keeps extra copies of every IDE. If you also use Android Studio, which is built on the same platform, the post on Android Studio's disk space covers its SDK and emulators.

JetBrains caches on a Mac: four folders per version

Every JetBrains IDE splits what it keeps into four kinds of folder. Three of them live in your own Library folder, each in a JetBrains folder of its own, and the fourth sits inside one of the others.

What are the four folders?

Folder	Where it lives, for IntelliJ IDEA 2026.2	What it holds
System	~/Library/Caches/JetBrains/IntelliJIdea2026.2	Indexes, caches and Local History
Configuration	~/Library/Application Support/JetBrains/IntelliJIdea2026.2	Your settings, keymaps, color schemes, scratches
Plugins	Inside the configuration folder, in plugins	Plugins you installed
Logs	~/Library/Logs/JetBrains/IntelliJIdea2026.2	Log files and thread dumps

The system folder is the large one, and the one people mean by "JetBrains caches". The configuration folder is usually much smaller, unless you've installed many plugins, and it holds things you set up by hand.

The logs folder grows slowly and holds nothing the IDE needs to run. JetBrains' own help pages list the same four locations for every IDE.

How are the folders named?

Each folder is named after the product and its release, without spaces. Bug-fix updates, such as 2026.2.1, keep using their release's folders, so you get a new set only when a new release, such as 2026.3, arrives.

IDE	Folder name for the 2026.2 release
IntelliJ IDEA	IntelliJIdea2026.2
PyCharm	PyCharm2026.2
WebStorm	WebStorm2026.2
GoLand	GoLand2026.2
CLion	CLion2026.2
Rider	Rider2026.2
PhpStorm, RubyMine, DataGrip, RustRover	PhpStorm2026.2 and so on

A Mac that has followed the IDEs for a few years can have many of these folders for each IDE. Any folder whose version you no longer run is a leftover, whatever its exact name.

How do you find the exact paths?

The quickest way is to ask the IDE. Choose Help › Diagnostic Tools › Special Files and Folders. It lists the folders the IDE is using, and you can show any of them in Finder or copy its path.

For logs, Help › Show Log in Finder opens the current version's log folder. To browse the folders by hand, open Finder, choose Go › Go to Folder, and type ~/Library/Caches/JetBrains. The Library folder is hidden by default; holding Option while you open the Go menu shows it too.

Which part of Storage settings counts them?

None of these folders belongs to an app category in System Settings › General › Storage. Caches, settings and logs in your Library folder usually count toward System Data, the category for files that don't fit anywhere else. The IDE apps themselves count under Applications.

That's why a growing JetBrains folder shows up as a growing System Data figure, with nothing in Storage settings to explain it. The steps work the same way on macOS 27 and macOS 26.

What's inside the system folder

The system folder is where the IDE keeps everything it works out about your code, so it doesn't have to work it out again. Its size follows the size and number of the projects you open, and the libraries they use.

What are indexes, and why are they so large?

To offer code completion, navigation, search and refactoring, the IDE reads every file in a project and records what it finds: every class, function, symbol and string it may need to look up. That record is the index, and the IDE keeps it up to date as files change.

A project's dependencies are indexed too: the JDK, Python packages, node_modules folders, Go modules and so on. A small project with large dependencies can produce a large index, and every project you open adds its own.

• Disk space IntelliJ IDEA asks for10 GB
• Caches of all JetBrains IDEs, typical1–20 GB · Usually safe
• One version's cache folder, in reports0.5–3 GB · Usually safe

The first figure is JetBrains' system requirement for IntelliJ IDEA 2026.2. The typical range is from the research behind the app's catalog; the per-version range is from developers' reports on JetBrains' forums. Many Macs have less.

The ranges are wide because projects differ. One version's folder for a few small projects can stay under a gigabyte, and a monorepo with many dependencies can push it much higher.

What is Local History?

Local History is the IDE's own record of the changes you make to your files, kept apart from Git or any other version control. It lets you restore a deleted file or an earlier state of a file from inside the IDE, even if you never committed it.

It's stored in a LocalHistory folder inside the system folder. By default, the IDE keeps revisions for the last five working days, meaning days on which you changed the file. You can change that period in the IDE's Settings, under Advanced Settings, with Duration of storing changes in Local History.

Why Local History changes what "cache" means

Local History is the one thing in the system folder that the IDE can't rebuild. That's why the app's catalog rates JetBrains IDE caches as Usually safe rather than Safe: removing a version's folder removes its record of your recent edits.

For an old version, that cost is close to nothing. JetBrains notes that Local History is cleared when you install a new version of the IDE, so a folder from a version you no longer run holds history the current version doesn't use.

For the version you use every day, it's worth a moment's thought. If you rely on Local History to recover work, remove that version's folder only when nothing in the last few days needs recovering.

What are shared indexes?

Shared indexes are indexes built once and reused, instead of being built on every Mac. JetBrains IDEs come with prebuilt indexes for the three latest long-term support releases of the JDK, and a project can be set up to download prebuilt indexes for its own code and dependencies.

Downloaded project indexes are stored in index/shared_indexes inside the system folder. To be asked before each download, open the IDE's Settings, go to Tools › Shared Indexes, and choose Ask before download under Project Shared Indexes. JetBrains doesn't document how much space they take.

Is it safe to delete the JetBrains caches folder?

Yes, with two conditions. Quit every JetBrains IDE first, so none of them is writing to its folder while you remove it. And accept that the Local History in each folder you remove is gone.

Remove the folders inside ~/Library/Caches/JetBrains, not the JetBrains folder itself. It also holds a folder that belongs to the Toolbox App, and Toolbox has its own settings for clearing it, covered below.

Old IDE versions: where most of the space goes

On a Mac that has run JetBrains IDEs for a few years, the folders of old versions usually outweigh the current ones. Each release starts a new set, and the old set has nothing left to do.

Why does every update leave a folder behind?

When you install a new release, the IDE uses a new set of folders, named for the new version. On its first start it offers to bring your settings across from the previous version, but it builds its own indexes and caches from scratch.

The previous version's folders stay where they were. If you still have that version installed, it keeps using them. If you don't, they're leftovers: settings, plugins, indexes and logs for an IDE that's no longer on your Mac.

Does the IDE clean up old versions by itself?

Partly. According to JetBrains, when you install a new release, the IDE deletes the caches and logs folders of older versions that haven't been updated in the last 180 days.

That leaves two gaps. Folders from versions you used within the last six months stay, which is most of them right after an upgrade. And configuration and plugins folders of older versions are kept indefinitely, whatever their age, until you remove them yourself.

How do you use Delete Leftover IDE Directories?

The IDE has a command for exactly this. It finds folders from older versions of the same IDE and offers to remove them.

1. Open the IDE you use now, such as IntelliJ IDEA or PyCharm.
2. Choose Help › Delete Leftover IDE Directories…. In some IDEs, a notification about leftover folders appears first; click View and Delete in it.
3. In the dialog, select the versions you no longer plan to use.
4. Click Delete.

The command covers the IDE it runs in. Run it once in each JetBrains IDE you use, so PyCharm finds old PyCharm folders and WebStorm finds old WebStorm folders.

JetBrains' documentation doesn't say the folders go to the Trash, so treat the deletion as final and select only versions you're sure you won't run again.

How do you remove old folders in Finder?

Finder works too, and it suits IDEs you no longer use at all, which have no current version to run the command from.

1. Quit every JetBrains IDE and the Toolbox App.
2. In Finder, choose Go › Go to Folder, type ~/Library/Caches/JetBrains and press Return.
3. Choose View › as List, then View › Show View Options and select Calculate all sizes, so Finder shows each folder's size.
4. Move the folders of versions you no longer run to the Trash. Leave the Toolbox folder and your current versions alone.
5. Do the same in ~/Library/Logs/JetBrains.
6. If you're sure you won't go back to an old version, do the same in ~/Library/Application Support/JetBrains for its settings and plugins.

Folders in the Trash still take space until you empty it. Open your current IDE and a project before you do, to check nothing you need went with them.

Which versions should you keep?

Keep the folders of every version you still have installed and might open. If you keep an older release for a project that doesn't work with the new one yet, its folders are in use.

Keep the configuration folder of the version you upgraded from for a while, too. If the new version's settings ever need repairing, the old folder is where they came from. Once the new version has run for a few weeks without trouble, the old one has done its job.

Invalidate Caches: a repair tool, not a cleanup tool

Search for ways to clear JetBrains caches, and most answers point to Invalidate Caches. It does clear caches, but it's built to fix a confused IDE, not to free space, and the space comes back as soon as you work.

What does Invalidate Caches remove?

Choose File › Invalidate Caches… in the IDE. When you click Invalidate and Restart, the IDE restarts and deletes the cache files of every project opened in this version of the IDE. They're built again when you open those projects.

It works on the current version only. Folders of older versions, which are usually the larger part, aren't touched. Clicking Just Restart in the same dialog restarts the IDE without deleting anything.

Which options in the dialog should you select?

The dialog has three optional checkboxes. Each removes something extra, and each is meant for a specific problem.

Option	What it removes	When to select it
Clear file system cache and Local History	The IDE's file system cache and your Local History	Only when invalidating alone didn't fix the problem
Clear VCS Log caches and indexes	The cache and index behind the Git log	When searching the log doesn't work properly
Delete embedded browser engine cache and cookies	The built-in browser's cache and cookies	Rarely; JetBrains says these files seldom break

Leave the first option unselected unless you're troubleshooting. It's the only way Invalidate Caches touches Local History, and it removes that history for every project.

What is Repair IDE?

File › Cache Recovery › Repair IDE is a gentler, step-by-step version of the same idea. It starts by refreshing the IDE's view of your files, then offers to rescan indexes, reopen the project, drop shared indexes and rebuild indexes, stopping whenever you click Everything Works Now.

Its last step, under More, is Invalidate Caches and Restart. So Repair IDE is worth trying first when the IDE misbehaves: it often fixes the problem without rebuilding everything.

Does Invalidate Caches free disk space?

Briefly, and only for the current version. The IDE rebuilds the indexes of each project as you open it, so as you go back to your usual projects, the folder grows back toward its earlier size.

The lasting gains come from removing what no longer has a use: old versions' folders, Toolbox's spare copies, and indexes of projects you've stopped opening. The next sections cover each.

Will clearing JetBrains caches make the IDE faster?

Not in general. Clearing caches frees space; it doesn't make the IDE or your Mac faster. Right afterwards the IDE is slower, while it indexes your projects again, and features such as code completion and search wait for indexing to finish.

Invalidate Caches can fix an IDE that's slow or wrong because its caches are damaged, for example when it marks working code as errors. That's a repair, and it's the job the command was built for.

Settings, plugins and logs: what to keep

The configuration folders in ~/Library/Application Support/JetBrains are a different kind of thing from caches. They hold choices you made, and the IDE can't recreate them from your projects.

What's in the configuration folder?

Each version's configuration folder holds your keymaps, color schemes, code style, file templates, live templates, inspection profiles and other options, plus scratch files and the plugins you installed. JetBrains' documentation calls these user-defined settings.

Scratch files are worth a special mention. They're notes and snippets you created in the IDE, outside any project, and they live in this folder, so removing an old version's configuration folder removes its scratches too.

Can you delete old versions' settings and plugins?

Yes, once you've moved to a newer version and it has your settings. Old configuration folders are kept indefinitely, so they're often the oldest JetBrains files on a Mac, and each one carries its own copy of every plugin you had then.

Before you remove them, you can keep a copy of your settings. Choose File › Manage IDE Settings › Export Settings, choose what to include, and save the archive somewhere safe. Import Settings in the same menu brings it back.

If you sync settings with a JetBrains Account through Backup and Sync, your settings are also stored there, and old local folders matter even less.

Should you ever delete the current version's configuration folder?

Not to free space. It's rarely large, and removing it resets the IDE to its defaults: your keymap, theme, code style and plugins are gone, and the IDE starts as if newly installed.

If a plugin takes a lot of space, uninstall it in the IDE instead. Open Settings, choose Plugins, click the Installed tab, select the plugin and uninstall it. That removes it cleanly and keeps the rest of your setup.

Are JetBrains logs safe to delete?

Yes. JetBrains IDE logs are Safe in the app's catalog: the IDEs and the Toolbox App write new logs as they run, and old ones are only useful when you report a problem to JetBrains.

Quit the IDEs first. The one cost is that past logs can't be attached to a support request afterwards, so if you're in the middle of one, wait until it's resolved.

The Toolbox App: spare copies and leftover folders

Many developers install JetBrains IDEs through the Toolbox App, which handles updates and can run several versions side by side. It's convenient, and it has its own reasons for using space.

Where does Toolbox put the IDEs?

On a Mac, Toolbox installs IDEs in the Applications folder inside your home folder, ~/Applications, rather than in the main Applications folder. You can change that in Toolbox's settings with Tools install location.

The IDEs it installs use the same four folders as any other copy: caches, configuration, plugins and logs, one set per version. Toolbox's own logs are in ~/Library/Logs/JetBrains/Toolbox, and its settings are in ~/Library/Application Support/JetBrains/Toolbox.

Why does Toolbox keep two copies of each IDE?

By default, Toolbox keeps the previously installed version of each tool after an update, so you can roll back at once if the update causes trouble. JetBrains says this is by design.

Each IDE is a large app, so for every IDE you have, you may be keeping a second full copy. One developer on JetBrains' forums reported that turning rollback off cut Toolbox's space roughly in half.

How do you reclaim Toolbox's space?

Toolbox's settings show what each of its extras takes and let you remove them.

1. Open the Toolbox App and click the settings icon in the upper-right corner of its window, then choose Settings.
2. Find the Tools section.
3. Under Keep previous versions of tools to enable instant rollback, click Remove the previous versions. To stop keeping them in future, turn the setting off.
4. Next to Clean up leftover tool directories, see how much space they take, then open the list. It groups leftover folders by tool and sorts them by date, and you can remove each tool's folders or all of them.
5. Next to Clear download cache, see how much space Toolbox's downloads take, and clear them.

The trade-off for step 3 is the one JetBrains names: without the previous version, you can't roll back an update instantly. You can still install an older version later, but that means a fresh download.

How do you remove a version you installed side by side?

Toolbox lets you install another version of an IDE next to the one you have: open the installed tool's menu and choose Other versions. That's useful for trying a release early or keeping an older one for a project, and each copy takes the full space of the app.

When you're done with one, open that copy's tool actions in Toolbox and choose Uninstall. If its folders stay behind in your Library, Delete Leftover IDE Directories in the version you keep, or Toolbox's leftover cleanup, takes care of them.

What if Toolbox can't update or remove an IDE?

JetBrains' FAQ describes a case on macOS where the Update button is unavailable and Toolbox says the installation path isn't writable. macOS may be blocking it from changing apps.

The fix it gives is in System Settings › Privacy & Security › App Management: make sure JetBrains Toolbox is in the list and turned on.

Other places JetBrains IDEs use space

The IDE folders aren't the whole story. JetBrains IDEs download tools for your projects and run build tools that keep caches of their own, and those land in other folders.

Where do downloaded JDKs go?

When you choose Download JDK in IntelliJ IDEA, the dialog shows where the JDK will be installed, and lets you change it. According to the IDE's source code, the default on a Mac is ~/Library/Java/JavaVirtualMachines, in your own Library folder.

Each JDK is a separate download, and older ones stay when you add newer ones. Removing a JDK from File › Project Structure, under SDKs, takes it off the IDE's list; JetBrains' documentation doesn't say it deletes the files.

To remove the files, quit the IDE and move that JDK's folder to the Trash in Finder, after checking no project still uses it.

JDKs installed by other installers usually live in /Library/Java/JavaVirtualMachines, the Mac-wide folder. Those belong to whatever installed them, so remove them the way they were installed.

Gradle, Maven and other build tool caches

IntelliJ IDEA and Android Studio run Gradle and Maven for Java and Kotlin projects, and both keep large caches in your home folder: ~/.gradle and ~/.m2. These belong to the build tools, not to the IDE, and clearing the IDE's caches doesn't touch them.

They can easily be larger than every JetBrains folder combined. The post on Gradle and Maven caches explains what's in them and what's safe to clear.

The same goes for the package caches behind PyCharm, WebStorm and GoLand projects: pip, npm, pnpm and Go each keep their own. The IDE indexes what they download, but the downloads themselves are the package manager's.

What about the .idea folder in each project?

Each project the IDE opens gets a hidden .idea folder at its root, which keeps that project's settings: run configurations, code style, inspection settings and the like. JetBrains describes it as where the project's settings are kept, not its caches.

It's small, and teams often keep parts of it in version control. Removing it doesn't free meaningful space; it only makes the IDE forget how the project was set up.

Local code completion models

JetBrains IDEs offer full line code completion, which runs on your Mac using language models downloaded to it. JetBrains says the models for Java and Kotlin come with IntelliJ IDEA, while others, such as JavaScript and TypeScript, are downloaded from the code completion settings.

JetBrains doesn't document where the models are stored or how large they are. If you don't use the feature for a language, turning it off for that language in the IDE's code completion settings is the documented way to manage it.

Android Studio and IntelliJ-based IDEs from others

Android Studio is built on the IntelliJ platform, so it follows the same pattern under a different name. Its folders are in Google folders, not JetBrains ones.

Where Android Studio differs

Android Studio's system folder is in ~/Library/Caches/Google, named like AndroidStudio2025.1, with its logs in ~/Library/Logs/Google. The catalog's entry for Android Studio caches rates it Usually safe, for the same reason as JetBrains': indexes rebuild, Local History doesn't.

Instead of Delete Leftover IDE Directories, Android Studio shows a Delete Unused Android Studio Directories dialog the first time you run a new major version. Its SDK, emulator images and virtual devices are much larger than its caches; the post on uninstalling Android Studio covers removing them with the app.

Running several JetBrains IDEs at once

If you use IntelliJ IDEA for Java, PyCharm for Python and WebStorm for front-end work, each keeps its own folders, and each indexes the projects you open in it. A project opened in two IDEs gets an index in each IDE's system folder.

That's not a mistake to fix, just something to know when the total looks high. If you've settled on one IDE for a kind of project, the others' folders for those projects are the ones that can go.

A safe order for cleaning up JetBrains IDEs

The folders differ in what they cost to remove, from nothing at all to settings you'd have to recreate. Working from the cheapest end keeps the risk low.

What does removing each folder cost?

What you remove	What it costs	How it comes back
Logs	Past logs for support requests	New logs as the IDE runs
An old version's system folder	That version's Local History	Not needed once the version is gone
Toolbox's previous versions	Instant rollback of the last update	A fresh download if you need it
The current version's system folder	Re-indexing, and its Local History	Rebuilt as you open projects
An old version's configuration folder	Its settings, plugins and scratches	An exported settings archive, if you made one
The current configuration folder	All your settings and plugins	Only from an export or Backup and Sync

In what order should you clean up?

1. Measure first. Check the size of the JetBrains folders in Caches, Application Support and Logs with Finder's Get Info or a disk map, so you know where the space is.
2. Run Delete Leftover IDE Directories in each JetBrains IDE you use, selecting only versions you won't run again.
3. Open Toolbox's settings and remove previous versions, leftover tool folders and the download cache.
4. Quit every IDE and Toolbox, then move folders of IDEs you've stopped using to the Trash in Finder.
5. Remove old logs from ~/Library/Logs/JetBrains.
6. Check your work. Open your IDE and a project, and let it finish indexing. Then empty the Trash.

Most Macs don't need the current version's folders touched at all. Leave them unless something is wrong with the IDE, and then use Repair IDE or Invalidate Caches rather than Finder.

Mistakes to avoid

• Moving the whole JetBrains folder in Application Support to the Trash. It takes your current settings and plugins with the old ones.
• Removing folders while an IDE is open. It's writing to them, and may recreate or damage them.
• Selecting Clear file system cache and Local History out of habit. It erases recent history for every project.
• Removing the folders of an old version you still have installed. Its next start will be slow, and its settings will be reset.
• Pasting a command from a web page to clear caches. Commands that delete files skip the Trash, and fake cleanup guides are a known way to install malware.

How do you keep it from growing back?

• After each upgrade, give the new version a few days, then run Delete Leftover IDE Directories.
• Turn off Toolbox's Keep previous versions setting once you trust updates, or clear previous versions after each one.
• Mark large folders the IDE doesn't need to understand, such as generated output, as excluded: right-click the folder in the Project tool window and choose Mark Directory As › Excluded. Excluded folders aren't indexed.
• Uninstall IDEs and side-by-side versions you've stopped using, then clear their folders.

Can you move the caches to another drive?

Yes. JetBrains documents a way to move the system folder, by choosing Help › Edit Custom Properties and setting idea.system.path to another folder, then restarting the IDE. Each folder kind has its own property, and JetBrains warns not to point two of them at the same folder.

The IDE reads and writes its indexes constantly, so pick a fast drive that's always connected. For most people, removing old versions frees more than moving the current one.

How the app does it

Wombit explains JetBrains folders like everything else on the disk. Select one in the map or the list, and you see what it is, how safe it is to remove and what removing it costs, from the catalog's entry. It reads only names, sizes and dates, and file names and paths never leave your Mac.

Each version's cache folder is its own item, so old versions are easy to tell apart from the one you use. Cleanup lists them by level:

• JetBrains logs are Safe. They count toward the safe total and start checked.
• Each version's system folder in ~/Library/Caches/JetBrains is Usually safe, because it holds Local History along with what rebuilds. It waits for you to check it. Toolbox's own folder there isn't part of that entry.
• Android Studio's per-version folders are Usually safe for the same reason.

• ~/Library/Caches/JetBrains/*

  JetBrains IDE caches

  Indexes, caches and Local History that IntelliJ IDEA, PyCharm, WebStorm and other JetBrains IDEs keep, in one folder per IDE version.

  Usually safe · Moves it to the Trash

• ~/Library/Logs/JetBrains

  JetBrains IDE logs

  Log files written by JetBrains IDEs and the Toolbox App, in one folder per IDE version.

  Safe · Moves it to the Trash

• ~/Library/Caches/Google/AndroidStudio*

  Android Studio caches

  Android Studio's system folder, with indexes, caches and local history, one for each version you've run.

  Usually safe · Moves it to the Trash

What you check goes to the Trash, where you can put it back, and the log keeps a record. Quit the IDE before you clean up, as you would in Finder.

Seeing all of this is free. Cleanup is PRO, one payment of $4.99 with lifetime access. Every Pro tool's review is free to open, so you see what would go and why before you buy.