Common Jetbrains Setup and Configuration


Jetbrains IDEs are standardized, so much of the setup and configuration information applies to all IDEs, and is consolidated on this page.

Any setup and configuration and other info that is specific to individual IDEs will be found on these sub-page under Individual IDEs. If this is the case, a link will be provided to the relevant section in the specific IDE’s sub-page.

Getting Help

  1. If you need help, ask in one of the Chat Groups!

Install the IDE

  1. Decide what IDE you need to use for the project you are working on:
    • RubyMine for Ruby/Rails/JS
    • GoLand for golang
    • Webstorm for pure-Javascript/Typescript.
    • Idea for JVM/Java/Kotlin
    • CLion for Rust
  2. If you are an GitLab employee, you can request and obtain a License for the IDE(s) you need to use.
  3. Install Jetbrains Toolbox.
  4. Use Jetbrains Toolbox to install the IDE you need.

At this point, you should be able to run the IDE and open the project you need to work on. For basic tasks, most things “just work” by default out of the box - that’s one of the nice things about using Jetbrains IDEs!

However, note that very large and complex projects such as the GitLab Rails monolith under RubyMine may an exception to this. Continue on with the rest of the instructions on this page for more details.


The most important thing to do related to indexing is to set up the proper excluded folders. See the Set up excluded folders section below.

Indexing Overview

One of the things that makes JetBrains IDEs powerful is their proprietary indexing technology, which indexes all of your project and dependency code, and allows for powerful and near-instantaneous searches and navigation across the project.

However, when you first open a new project for the first time, or if you pull in significant updates to a project, it can take a while to update the indexes, especially on a slower machine.

And for very large projects, such as the GitLab Rails monolith, which has more than 2 million lines of Ruby code, and who knows how many millions of lines of gem code dependency, the very first indexing can take a very long time, up to 15-20 minutes or more depending on your machine. However, after that initial indexing, subsequent incremental indexing after pulling new changes or switching branches usually takes no more than a minute or so.

As long as you’ve already set up the proper excluded folders, the best advice here is to just “be patient” - the good news is that it is only required once, when you first open the project or pull in new changes. Use this opportunity to take a little break, do a little stretching… 🧘🏼

Shared Indexes

JetBrains does offer support for Shared Indexes for RubyMine (and other IDEs), which have the potential to greatly reduce the indexing time for people setting up the GitLab project for the first time.

However, this seems to be an involved setup process. If you are interested in helping set up and maintain shared indexes, please let us know in one of the Chat Groups!

Set up excluded folders

It’s important to set up the excluded folders, otherwise indexing and searching will take much longer than necessary.

This will be under Settings -> Project Structure in RubyMine and GoLand, and under Settings -> Directories under WebStorm.

If you want to see a current example of the RubyMine excluded folders for the gitlab project, you can see Chad’s gitlab.iml module at, and search for excludeFolder.

Alternately, these would be included in the config if you use one of the “copy someone else’s config” Configuration approaches under Configuration.

Increase maximum heap size in memory settings

When working with the GitLab project, which is BIG, RubyMine can use a lot of memory when indexing/searching/etc. It’s not unusual for memory usage to peak out at up to 10 gigabytes or more of memory during indexing, if it is allocated.

If you have the memory to spare on your workstation, it will help your performace to allocate a lot of memory. 12 gigabytes is a good start.

  1. Help menu -> Change Memory Settings
  2. Change Maximum heap size to 12000 Mib, or whatever you think you can allocate without otherwise impacting system performance. On a maxed-out MacBook pro with 64G of memory, allocating 12G should be fine.



If you want to get your JetBrains (RubyMine) configured to work (and specifically work with Gitlab):

  1. Your best bet is probably “Manual Option 1: Manually configure everything”. This will take maybe an hour or so, but you’ll learn your way around the settings.
  2. If you are in a hurry, consider “Manual option 2: Manually zip and copy IDE and Project config folders” and ask on Chat Groups for a zip of someone’s config folders
  3. If you just want to backup or transfer your existing config, consider “JetBrains-supported option 1: Settings Sync”
  4. If you have aspirations to be a JetBrains power user, or are the type of person who wants to keep all your configs under source control, see “JetBrains-supported option 2: Settings Repository” and “Manual option 3: Keep your .idea folder under source control”.


NOTE: This Configuration section is a work in progress, especially since the options for managing/sharing configs have changed in recent versions of JetBrains. Please feel free to contribute any updates you may have.

Although most basic functionality works out of the box in JetBrains IDEs, if you work on a project with very specific and strict rules around code style and formatting (such as GitLab) you may need to carefully curate your IDE configuration to match the requirements of the project. For example, matching all code formatting and linting rules defined by the project.

Ideally, you would just want to import a pre-existing configuration that someone else is already curating and maintaining to keep it up-to-date with the project.

Unfortunately, this isn’t as easy as it should be, and this is one of the areas that JetBrains IDEs could use a lot of improvement, as is evidenced by the 5 different approaches documented below.

This section will attempt to provide some solutions for this. But if you are new to JetBrains, please feel free to ask for guidance and advice in the Chat Groups.

“IDE” vs. “Project” config

Jetbrains stores config in two ways: “Stored in IDE” and “Stored in Project”:

  • The “IDE” settings are stored under your home directory, in a directory like /Users/cwoolley/Library/Application Support/JetBrains/RubyMine2023.2
  • The “Project” settings are stored in the .idea folder in the root of your project.

And some types of config allow you to choose which of those to use. It’s probably better to store everything possible in the project.

Here’s how you set that up:

  1. Settings -> Editor -> Code Style -> Scheme -> "Project"
  2. Settings -> Editor -> Inspections -> Scheme -> "Project Default"
  3. Settings -> Editor -> File and Code Templates -> "Project"

Manual option 1: Manually configure everything

You can manually go into settings and make all the changes yourself.

Chad Woolley maintains documentation on how to manually configure JetBrains IDEs to work in an optimal and compatible way, specifically the GitLab monorepo.

If you have some time, this can be the simplest approach, and also lets you have more control than the other approaches of copying entire configs.

If you want to do this, you can just follow these instructions - it should take maybe a half hour to an hour.

These are a bit scattered as they have evolved over multiple years, projects, and IDE versions. Chad hopes to migrate and consolidate all these instructions to this page and sub-pages page real soon™️.

Manual option 2: Manually zip and copy IDE and Project config folders

Ask someone who already has the project configured to give you zipped copies of their IDE and Project config folders listed above. This SHOULDN’T contain any personal information other than perhaps dictionary override entries, but some plugins might store personal info in their own configs.

You should also ensure you are both on the exact same version of the IDE product.

Then you can backup your own folders (just in case), close the IDE, and unzip theirs to the same place. This should theoretically give you all their settings.

Also, Chad Woolley keeps his current .idea Project Config folder for the gitlab project committed and updated in source control (see instructions on how you can do this in the next section).

You can clone it or copy any files from this config here:

Manual option 3: Keep your .idea folder under source control

If you want to keep your Project (not IDE) config under source control, you can do this manually. See Chad’s instructions here:

JetBrains-supported options

JetBrains provides three different options for sharing settings, which are described on the following page (using RubyMine as an example):

  1. Settings Sync
  2. Settings Repository
  3. Settings Export/Import

Each of these have their tradeoffs, see the following sections for details.

JetBrains-supported option 1: Settings Sync

This approach is described here:

The main downside of this approach is that since this is done through your JetBrains account, there appears to be no way to share with other team members. So, you’ll have to one of the other approaches if you want to share your settings with someone else, or have them share theirs with you.

JetBrains-supported option 2: Settings Repository

This involves syncing your IDE-level (not-project level) config to a git repo.

This approach has a few downsides:

  1. It only manages IDE-level config, not project-level config
  2. It’s complex to set up, involving setting up a custom repo with HTTPS credentials
  3. It doesn’t support all git features (e.g. .gitignore seems to be ignored)
  4. It doesn’t seem well-supported by JetBrains, especially since they moved it out of being bundled with the IDE and made it a plugin.

The upside of it is that you can keep your IDE-level config under source control in your own repo, and not in JetBrains cloud as is done with “Settings Sync” above. This also means you can share it yourself as needed.

Here’s the docs:

  1. It’s mentioned as the second approach here:
  2. …which links here to an old version of the docs for the real instructions:
  3. …and you can also see some instructions Chad has written around it here:

JetBrains-supported option 3: Export/Import your settings

This approach is documented here:

It is found under File -> Manage IDE Settings -> Import/Export Settings

I (Chad) haven’t tested this approach much. I THINK it only does IDE-level settings.

Please feel free to update this section if you experiment with this and learn more details.