# RBS

> For the complete documentation index, see [llms.txt](https://www.jetbrains.com/help/ruby/llms.txt).

> **TL;DR**
> RubyMine comes with the `rbs` gem bundled.
>
>
>
> If you need a different RBS version, add the `rbs` gem to your `Gemfile` and [install it to your project interpreter](using-the-bundler.html#install_gems_local).

RubyMine supports the [RBS](https://github.com/ruby/rbs) language to describe the types used in Ruby programs. RubyMine recognizes `.rbs` files and provides the following coding assistance:

* Error and syntax highlighting

* [Code formatting](reformat-and-rearrange-code.html)

* [Code completion](auto-completing-code.html)

* AI-powered [inline prompts](https://www.jetbrains.com/help/ai-assistant/code-generation.html) and [cloud code completion](https://www.jetbrains.com/help/ai-assistant/code-completion.html)

* [Search for usages](find-highlight-usages.html)

* [Code navigation](navigating-through-the-source-code.html)

* [Inspections](code-inspection.html)

* [Rename refactorings](rename-refactorings.html)

* Code commenting using `Ctrl+/` (Windows), `⌘ /` (macOS), `⌘ /` (IntelliJ IDEA Classic (macOS)), `⌘ /` (macOS System Shortcuts), `Ctrl+/` (XWin), `Ctrl+/` (GNOME), `Ctrl+/` (KDE), `Alt+;` (Emacs), `Ctrl+/` (Sublime Text), `⌘ /` (Sublime Text (macOS)), `Ctrl+Alt+/` (Visual Studio), `⌘ ⌥ /` (Visual Studio (macOS)), `Meta+/` (TextMate), `Ctrl+/` (NetBeans), `Ctrl+/` (Eclipse), `⌘ /` (Eclipse (macOS))

* [Copyright insertion](copyright.html#paste-copyright)

* RBS-related [code inspections](code-inspection.html) and [intention actions](intention-actions.html).

RBS provides a set of built-in type signatures for the standard libraries out of the box. When you use RBS in your project, RubyMine displays its sources in external libraries.

RubyMine can also work with your `rbs_collection.lock.yaml` file. In this scenario, RubyMine will determine which type signatures will be loaded and used for code insight. For more information, refer to the [documentation](https://github.com/ruby/rbs/blob/master/docs/collection.md).

## RBS type signatures

RubyMine supports RBS type signatures and uses them to determine the type of Ruby elements. This helps you to experience better code insight when developing your code in Ruby.

If you have RBS files in your project, RubyMine provides:

* Better method completion RubyMine displays methods from appropriate classes at the beginning of the list, when invoking code completion. ![Method name completion with RBS](https://resources.jetbrains.com/help/img/idea/2026.3/rm_code_completion_with_rbs.png)

* Extra declarations from RBS in Ruby completion RubyMine recognize extra declarations from RBS when they are absent in your Ruby files. This is particularly beneficial for projects that extensively use reflection, as it allows for these declarations to still be present in completion. The feature is available for classes, modules, constants, methods, and variables. ![Extra declarations from RBS](https://resources.jetbrains.com/help/img/idea/2026.3/rm_rbs_extra_declarations.png)

* Improved navigation actions When you invoke the 'Go to declaration' action, RubyMine navigates you to the exact declaration instead of providing a list of declarations to choose from. [Video](https://resources.jetbrains.com/help/img/idea/2026.3/rm_go_to_declaration_rbs.mp4)

* Search for usages of the corresponding declaration With RBS types, RubyMine can find the correct declaration of a Ruby element. When you invoke the 'Refactor' action, RubyMine instantly finds usages of the corresponding declaration instead of giving you a list of declarations to choose from. ![Find usages with RBS](https://resources.jetbrains.com/help/img/idea/2026.3/rm_find_usages_rbs.png)

* Consistent rename refactorings When RubyMine utilizes RBS, it will only suggest renaming relevant entities instead of showing all potential options. ![Rename refactoring with RBS](https://resources.jetbrains.com/help/img/idea/2026.3/rm_rename_with_RBS.png)

Procedure: View the type info

* Having RBS signatures provided, RubyMine uses them to determine types of Ruby elements. To view the element type, place the caret at the desired Ruby element and go to `View | Type Info` `Ctrl+Shift+P` (Windows), `⌃ ⇧ P` (macOS), `⌃ ⇧ P` (IntelliJ IDEA Classic (macOS)), `⌃ ⇧ P` (macOS System Shortcuts), `Ctrl+Shift+P` (XWin), `Ctrl+Shift+P` (GNOME), `Ctrl+Shift+P` (KDE), `Ctrl+Shift+P` (Emacs), `Ctrl+Shift+P` (Sublime Text), `⌃ ⇧ P` (Sublime Text (macOS)), `Ctrl+Shift+P` (Visual Studio), `Ctrl+Shift+P` (Visual Studio (macOS)), `Ctrl+Shift+P` (TextMate), `Ctrl+Shift+P` (NetBeans), `Ctrl+Shift+P` (Eclipse), `Ctrl+Shift+P` (Eclipse (macOS)) in the main menu.

![Viewing type info](https://resources.jetbrains.com/help/img/idea/2026.3/rm_view_type_info_rbs.png)

Procedure: View the parameter info

RubyMine uses RBS signatures to display types of method parameters in the [Parameter info](viewing-reference-information.html#view-parameter-info) popup. By default, RubyMine shows the popup automatically after you type an opening bracket in the editor or select a method from the list of suggestions.

* To invoke the Parameter info popup explicitly, go to `View | Parameter Info` `Ctrl+P` (Windows), `⌘ P` (macOS), `⌘ P` (IntelliJ IDEA Classic (macOS)), `⌘ P` (macOS System Shortcuts), `Ctrl+P` (XWin), `Ctrl+P` (GNOME), `Ctrl+P` (KDE), `Alt+Shift+P` (Emacs), `Ctrl+P` (Sublime Text), `Ctrl+P` (Sublime Text (macOS)), `Ctrl+Shift+Space` (Visual Studio), `⌘ P` (Visual Studio (macOS)), `Meta+P` (TextMate), `Ctrl+P` (NetBeans), `Ctrl+P` (Eclipse), `⌃ ⇧ Space` (Eclipse (macOS)) in the main menu.

![View Parameter Info](https://resources.jetbrains.com/help/img/idea/2026.3/rm_view_parameter_info_rbs.png)

Procedure: Check the types match

* RubyMine warns you when you try to use types that don't agree with the types from RBS files.

![Incompatible parameter type](https://resources.jetbrains.com/help/img/idea/2026.3/rm_incompatible_types_rbs.png)

You can manage these warnings using the Mismatched type [inspections](code-inspection.html). The inspections are available for:

* Constant assignments

* Assignments to instance and class variables (including instance variables in singleton classes/methods)

* Parameter assignments in methods and blocks

* Return values of methods and blocks

* Arguments in methods and `yield` calls

Procedure: View Quick Documentation

You can use [Quick Documentation](viewing-reference-information.html) to get information about RBS signatures in use.

[Video](https://resources.jetbrains.com/help/img/idea/2026.3/rbs_quick_docs.mp4)

1. Hover over the necessary symbol in the editor.

2. Place the caret at the symbol and press `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Middle-Click` (TextMate), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS)) or select `View | Quick Documentation` from the main menu.

Press `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Middle-Click` (TextMate), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS)) again to open this documentation in the Documentation tool window.

3. Click ![the Show Options Menu icon](https://resources.jetbrains.com/help/img/idea/2026.3/app.actions.more.svg)  in the popup to change the font size, display the quick documentation toolbar, or go to the source code.

> **Note:**
> To toggle the focus between the Quick Documentation popup and the Documentation tool window, press `Ctrl+Q` (Windows), `F1` (macOS), `⌃ J` (IntelliJ IDEA Classic (macOS)), `⌘ I` (macOS System Shortcuts), `Ctrl+Q` (XWin), `Ctrl+Q` (GNOME), `Ctrl+Q` (KDE), `Ctrl+Q` (Emacs), `Ctrl+Q` (Sublime Text), `Ctrl+Q` (Sublime Text (macOS)), `Ctrl+K, I` (Visual Studio), `⌘ K, I` (Visual Studio (macOS)), `Ctrl+Middle-Click` (TextMate), `Ctrl+Q` (NetBeans), `Alt+Middle-Click` (Eclipse), `⌥ Middle-Click` (Eclipse (macOS)) sequentially.

## RBS Collection

RubyMine features built-in integration with [RBS Collection](https://github.com/ruby/gem_rbs_collection), a community-managed collection of RBS files for gems that do not include their own type signatures. With this integration, you can benefit from type signatures for your project dependencies even if you don’t use RBS explicitly. RubyMine seamlessly downloads these type signatures in the background, improving type support and code insight for all gems in your project.

You can find the downloaded type signatures in the External Libraries node under `rbs_collection [bundled]`.

The functionality is enabled by default and requires your project interpreter to have an RBS gem of version 3.2 or higher installed. While Ruby 3.4 comes with a compatible version, if your interpreter has an earlier RBS version or lacks the gem entirely, RubyMine shows a notification that prompts installing the latest version.

![Install RBS from the notification](https://resources.jetbrains.com/help/img/idea/2026.3/install-rbs-notification.png)

> **Tip:**
> To disable the feature, go to `Settings | Languages & Frameworks | RBS` and clear the Improved type support with RBS collection checkbox.
>
>
>
> ![RBS Collection settings](https://resources.jetbrains.com/help/img/idea/2026.3/rbs-collection-settings.png)

## Create an RBS file

Procedure:

1. In the Project view `Alt+1` (Windows), `⌘ 1` (macOS), `⌘ 1` (IntelliJ IDEA Classic (macOS)), `⌘ 1` (macOS System Shortcuts), `Alt+1` (XWin), `Alt+1` (GNOME), `Alt+1` (KDE), `Alt+1` (Emacs), `Alt+1` (Sublime Text), `⌘ 1` (Sublime Text (macOS)), `Ctrl+Alt+L` (Visual Studio), `⌘ ⌥ L` (Visual Studio (macOS)), `Meta+1` (TextMate), `Ctrl+1` (NetBeans), `Alt+1` (Eclipse), `Alt+1` (Eclipse (macOS)), select the directory where you want to create a new RBS file.

2. Press `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Alt+Insert` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `Alt+Insert` (Visual Studio), `⌘ ⌃ N` (Visual Studio (macOS)), `Ctrl+N` (TextMate), `Alt+Insert` (NetBeans), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)) and select RBS File/Class from the popup.

![Create a new RBS file](https://resources.jetbrains.com/help/img/idea/2026.3/rm_create_rbs_file.png)

As another option, select `File | New | RBS File/Class` from the main menu.

3. Specify the filename and press `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (TextMate), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)).

> **Tip:**
> You can use qualified names when creating a new RBS file. RubyMine will split them on the `::` symbol and create the surrounding modules for all qualifiers.

### Generate an RBS prototype

RubyMine provides a tool to generate simple [signature
prototypes](https://github.com/ruby/rbs/blob/master/docs/stdlib.md#generating-prototypes) from your Ruby code. These prototypes may help to figure out how to start adding new RBS types to your project.

Procedure:

1. Open a Ruby file, for which you want to generate type signatures.

2. In the main menu, go to `Code | Generate` `Alt+Insert` (Windows), `⌘ N` (macOS), `⌃ N` (IntelliJ IDEA Classic (macOS)), `⌘ N` (macOS System Shortcuts), `Alt+Insert` (XWin), `Alt+Insert` (GNOME), `Alt+Insert` (KDE), `Alt+Insert` (Emacs), `Alt+Insert` (Sublime Text), `⌘ N` (Sublime Text (macOS)), `Alt+Insert` (Visual Studio), `⌘ ⌃ N` (Visual Studio (macOS)), `Ctrl+N` (TextMate), `Alt+Insert` (NetBeans), `Alt+Insert` (Eclipse), `⌘ N` (Eclipse (macOS)).

3. Select Type Signatures in the Generate popup.

![Generate an RBS prototype](https://resources.jetbrains.com/help/img/idea/2026.3/rm_generate_rbs.png)

RubyMine will generate a new RBS file with the same name as your Ruby file. All types included in the resulting prototype are specified as `untyped`. You can use them as templates for writing type signatures.

### Add a missing type signature using a quick-fix

You can always add a missing type signature using the quick-fix for the Missing Type Signature inspection. RubyMine will navigate you to the existing RBS file, or create a new RBS file if necessary, and generate a respective signature template.

> **Note:**
> This functionality only applies to declarations of methods, attributes, instance, class, and global variables, constants, and method aliases.

Procedure:

1. Place the caret at the Ruby symbol that is missing a type signature.

2. Press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (TextMate), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) or click the ![the Intention action button](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.codeInsight.intentionBulb.png) icon at the line with the problem.

![Add a missing type signature](https://resources.jetbrains.com/help/img/idea/2026.3/rbs_add_signature_quick-fix.png)

3. Select the Add type signature fix from the menu.

4. In the RBS file that opens, update the type signature.

### Edit a type signature

RubyMine allows you to edit type signatures from your Ruby file using the dedicated intention action or the quick-fix available for the Mismatched Type inspection.

> **Note:**
> This functionality only applies to declarations of methods, attributes, instance, class, and global variables, constants, and method aliases.

Procedure:

1. Place the caret at the Ruby symbol, which type signature you want to edit.

2. Press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (TextMate), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)) and select Edit type signature from the menu.

Intention action:

![Edit a type signnature using an intention](https://resources.jetbrains.com/help/img/idea/2026.3/rbs_edit_signature_intention.png)

Mismatched Type quick-fix:

![Edit a type signnature using a quick-fix](https://resources.jetbrains.com/help/img/idea/2026.3/rbs_edit_signature_quickfix.png)

3. In the RBS file that opens, update the type signature.

### View the structure of an RBS file

You can examine the high-level structure of an RBS file using the Structure [tool window](viewing-structure-of-a-source-file.html) `Alt+7` (Windows), `⌘ 7` (macOS), `⌘ 7` (IntelliJ IDEA Classic (macOS)), `⌘ 7` (macOS System Shortcuts), `Alt+7` (XWin), `Alt+7` (GNOME), `Alt+7` (KDE), `Alt+7` (Emacs), `Alt+7` (Sublime Text), `⌘ 7` (Sublime Text (macOS)), `Ctrl+Alt+F` (Visual Studio), `⌃ ⌥ F` (Visual Studio (macOS)), `Meta+7` (TextMate), `Ctrl+7` (NetBeans), `Alt+7` (Eclipse), `⌘ 7` (Eclipse (macOS)).

![Structure tool window](https://resources.jetbrains.com/help/img/idea/2026.3/rm_rbs_structure_view.png)

## Navigate between Ruby and RBS files

RubyMine enables you to navigate from a Ruby declaration to its type signature, and vice versa. Navigation features are available for:

* Attributes (currently works only when navigating from RBS to Ruby)

* Classes, modules, and constants

* Class and instance variables

* Global variables

* Methods (including `singleton`)

Procedure: Go to the type signature

* Select a Ruby declaration and go to `Navigate | Type Signature` to navigate to its type signature.

![Navigating between a Ruby declaration and its type signature](https://resources.jetbrains.com/help/img/idea/2026.3/rm_navigate_between_rb_rbs.animated.gif)

Procedure: Go to the associated Ruby declaration

* Select a type signature and go to `Navigate | Associated Declaration` to navigate to the associated Ruby declaration.

![Navigating between an RBS signature and an associated Ruby declaration](https://resources.jetbrains.com/help/img/idea/2026.3/rm_navigate_from_rbs_to_rb.animated.gif)

> **Tip:**
> These actions come without default shortcuts. If you use them frequently, consider assigning your own shortcuts.
>
>
>
> 1.    In the Settings dialog (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Meta+Comma` (TextMate), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))), select Keymap .
>
> 2.  Find the `Go to Type Signature or Associated Declaration` action using the search field. Double-click the action to set a shortcut for it.

Procedure: Navigate with intention actions

1. Place the caret at the required element and press `Alt+Enter` (Windows), `⌥ ⏎` (macOS), `⌥ ⏎` (IntelliJ IDEA Classic (macOS)), `⌥ ⏎` (macOS System Shortcuts), `Alt+Enter` (XWin), `Alt+Enter` (GNOME), `Alt+Enter` (KDE), `Alt+Enter` (Emacs), `Alt+Enter` (Sublime Text), `⌥ ⏎` (Sublime Text (macOS)), `Alt+Enter` (Visual Studio), `⌥ ⏎` (Visual Studio (macOS)), `Alt+Enter` (TextMate), `Alt+Enter` (NetBeans), `Ctrl+1` (Eclipse), `⌘ 1` (Eclipse (macOS)).

2. Select the action to navigate to the required type signature or associated declaration from the list. Press `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (TextMate), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)) to apply the intention action.

![Navigate with intention actions](https://resources.jetbrains.com/help/img/idea/2026.3/rm_rbs_navigate_intention.animated.gif)

Procedure: Navigate to a related Ruby or RBS element

1. Place the caret at the required element and go to `Navigate | Related Symbol` `Ctrl+Alt+Home` (Windows), `⌘ ⌃ ↑` (macOS), `⌘ ⌥ Home` (IntelliJ IDEA Classic (macOS)), `⌘ ⌃ ↓` (macOS System Shortcuts), `Ctrl+Alt+Home` (XWin), `Ctrl+Alt+Home` (GNOME), `Ctrl+Alt+Home` (KDE), `Ctrl+Alt+Home` (Emacs), `Ctrl+Alt+Home` (Sublime Text), `Ctrl+Alt+Home` (Sublime Text (macOS)), `Ctrl+Alt+F7` (Visual Studio), `⌘ ⇧ F7` (Visual Studio (macOS)), `Meta+Alt+Home` (TextMate), `Ctrl+Alt+Home` (NetBeans), `Ctrl+Alt+Home` (Eclipse), `⌘ ⌃ ↑` (Eclipse (macOS)) in the main menu.

2. Select the desired target from the popup if required.

![Navigate to a related Ruby element](https://resources.jetbrains.com/help/img/idea/2026.3/rm_rbs_navigate_to_related.animated.gif)

## Check Ruby types using Steep

RubyMine supports running [Steep](https://github.com/soutaro/steep) commands using [Run anything](running-anything.html). Before working with Steep, make sure to add the `steep` gem to your `Gemfile`:

```RUBY
gem 'steep'
```

After [installing Steep](using-the-bundler.html), you need to generate a `Steepfile` for your project.

Procedure: Generate and configure a Steepfile

1. Press `Ctrl` (Windows), `Ctrl` (macOS), `Ctrl` (IntelliJ IDEA Classic (macOS)), `Ctrl` (macOS System Shortcuts), `Ctrl` (XWin), `Ctrl` (GNOME), `Ctrl` (KDE), `Ctrl` (Emacs), `Ctrl` (Sublime Text), `Ctrl` (Sublime Text (macOS)), `Ctrl` (Visual Studio), `Ctrl` (Visual Studio (macOS)), `Ctrl` (TextMate), `Ctrl` (NetBeans), `Ctrl` (Eclipse), `Ctrl` (Eclipse (macOS)) twice.

2. Start typing `steep init` in the search field. Select the command from the list of suggestions and press `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (TextMate), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)). RubyMine will generate a `Steepfile` for your project.

3. Open and edit the generated `Steepfile`. For example:

```RUBY
target :lib do
  check "lib"
  signature "sig"

  library "set", "pathname"
end
```

Procedure: Run type checking

1. Press `Ctrl` (Windows), `Ctrl` (macOS), `Ctrl` (IntelliJ IDEA Classic (macOS)), `Ctrl` (macOS System Shortcuts), `Ctrl` (XWin), `Ctrl` (GNOME), `Ctrl` (KDE), `Ctrl` (Emacs), `Ctrl` (Sublime Text), `Ctrl` (Sublime Text (macOS)), `Ctrl` (Visual Studio), `Ctrl` (Visual Studio (macOS)), `Ctrl` (TextMate), `Ctrl` (NetBeans), `Ctrl` (Eclipse), `Ctrl` (Eclipse (macOS)) twice.

2. Start typing `steep check` in the search field. Select the command from the list of suggestions and press `Enter` (Windows), `⏎` (macOS), `⏎` (IntelliJ IDEA Classic (macOS)), `⏎` (macOS System Shortcuts), `Enter` (XWin), `Enter` (GNOME), `Enter` (KDE), `Enter` (Emacs), `Enter` (Sublime Text), `⏎` (Sublime Text (macOS)), `Enter` (Visual Studio), `⏎` (Visual Studio (macOS)), `Enter` (TextMate), `Enter` (NetBeans), `Enter` (Eclipse), `⏎` (Eclipse (macOS)).

RubyMine will display the command output in the Run tool window.

![Command output in the Run tool window](https://resources.jetbrains.com/help/img/idea/2026.3/rm_steep_check_output.png)

## Configure code style settings

RubyMine applies the same code style settings for both Ruby and RBS. To customize the [code style](configuring-code-style.html) for RBS:

Procedure:

1. In the Settings dialog (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Meta+Comma` (TextMate), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))), go to `Editor | Code Style | Ruby`.

2. Configure the desired code style settings.

## Configure syntax highlighting

RubyMine uses the Ruby color scheme to highlight the syntax in RBS files.

You can configure RBS-aware syntax highlighting according to your preferences and habits.

Procedure:

1. In the Settings dialog (`Ctrl+Alt+S` (Windows), `⌘ Comma` (macOS), `⌘ Comma` (IntelliJ IDEA Classic (macOS)), `⌘ Comma` (macOS System Shortcuts), `Ctrl+Alt+S` (XWin), `Ctrl+Alt+S` (GNOME), `Ctrl+Alt+S` (KDE), `Ctrl+Alt+S` (Emacs), `Ctrl+Alt+S` (Sublime Text), `⌘ Comma` (Sublime Text (macOS)), `Ctrl+Alt+S` (Visual Studio), `⌘ Comma` (Visual Studio (macOS)), `Meta+Comma` (TextMate), `Ctrl+Alt+S` (NetBeans), `Ctrl+Alt+S` (Eclipse), `⌘ Comma` (Eclipse (macOS))), go to `Editor | Color Scheme | Ruby`.

2. Select the color scheme, accept the highlighting settings inherited from the defaults or customize them as described in [Colors and fonts](configuring-colors-and-fonts.html).

