Code insight

RubyMine 2026.1 introduces a new symbol-based language modeling engine for Ruby.

This experimental engine changes how RubyMine understands Ruby code, especially classes, modules, and constants. Support for methods is planned for future releases.

The new engine brings three main improvements:

clearer and more consistent code insight
better handling of dynamic Ruby constructs
faster performance in key IDE actions

UX improvements in code insight features

Several code insight features have been refined to make working with Ruby symbols across namespaces easier and more predictable.

Completion for classes, modules, and constants

Code completion has been significantly improved, especially for qualified constants.

Feature	Improvement
Fuzzy search across namespaces	Completion now supports fuzzy search across namespaces, allowing you to locate symbols even if you only type fragments of their qualified name. This behavior is similar to Search Everywhere, so you can find symbols without typing the full namespace.
Namespace-aware completion	When a namespace prefix is already typed, completion shows only elements from that namespace. For example, RubyMine suggests only elements declared inside `Foo`. Fuzzy matching still works within that namespace.
Automatic shortening of qualified names	When inserting a completion result, RubyMine determines whether the name can be shortened without breaking resolution. If `Foo::Bar` is selected, RubyMine inserts `Bar` instead of the fully qualified name when the shorter name resolves correctly.
Completion presentation	The completion popup now provides clearer information about suggested elements. The right-hand side of each item shows the fully qualified name Completion items include context-specific icons Examples of supported icons include: exceptions Rails models Rails controllers Rails mailers

Find Usages

The Find Usages results view has been updated to make results easier to scan.

Feature	Improvement
Clearer grouping of results	Usages are now organized into separate chapters: Usages, Potential usages, and Text occurrences. Separating potential usages from confirmed results reduces noise in large projects.
Text occurrences	Find Usages now detects occurrences inside comments and strings. These are displayed in a separate Text Occurrences chapter. Symbol literals are also grouped there.

Feature

Improvement

Clearer grouping of results

Usages are now organized into separate chapters: Usages, Potential usages, and Text occurrences.

Separating potential usages from confirmed results reduces noise in large projects.

Text occurrences

Find Usages now detects occurrences inside comments and strings.

These are displayed in a separate Text Occurrences chapter. Symbol literals are also grouped there.

Rename refactoring

Feature	Improvement
Inline renaming	You can now rename symbols directly in the editor without opening a modal dialog.
Excluding usages	Before applying a rename refactoring, you can exclude specific usages from the results list to control which references are renamed.

Quick Documentation and hover hints

Feature	Improvement
Quick Documentation	When a symbol has multiple declarations, Quick Documentation now displays them as separate pages instead of merging them into a single view.
Hover hints	Hover hints now provide: syntax highlighting clearer formatting correct navigation targets when multiple declarations exist

Feature

Improvement

Quick Documentation

When a symbol has multiple declarations, Quick Documentation now displays them as separate pages instead of merging them into a single view.

Hover hints

Hover hints now provide:

syntax highlighting
clearer formatting
correct navigation targets when multiple declarations exist

Structure view

The Structure view has several presentation improvements:

Container nodes no longer show expand arrows when they have no children.
Nested declarations are displayed with their full names (for example, Bar1::Baz1).
Singleton classes defined as class << self are shown as << self.
Absolute references now display the :: prefix.
Entries with the same simple name are no longer hidden.
Singleton classes now use the anonymous class icon.
Inherited members are displayed correctly and in natural order, including for singleton classes, with improved location formatting.

Navigation

Feature	Improvement
Go to Declaration	The new implementation replaces the old reference mechanism and serves as a foundation for other code insight features, including Find Usages, Rename, and Quick Documentation. Qualified name resolution is also faster because RubyMine now loads only relevant symbols instead of the entire model.
Go to Type Declaration	Navigation now works in cases that previously failed, including class and module constants, RBS types, and complex types such as unions. When invoked on a class or module, navigation now prefers the singleton class if it exists; otherwise, it navigates to the regular class or module definition.

Feature

Improvement

Go to Declaration

The new implementation replaces the old reference mechanism and serves as a foundation for other code insight features, including Find Usages, Rename, and Quick Documentation. Qualified name resolution is also faster because RubyMine now loads only relevant symbols instead of the entire model.

Go to Type Declaration

Navigation now works in cases that previously failed, including class and module constants, RBS types, and complex types such as unions.

When invoked on a class or module, navigation now prefers the singleton class if it exists; otherwise, it navigates to the regular class or module definition.

Improved handling of dynamic Ruby constructs

The new engine also improves code insight for symbols that are not explicitly declared in Ruby source files.

This includes symbols introduced through framework conventions, type definitions, and dynamic Ruby constructs. These symbols are now recognized in code insight and work more consistently across the IDE.

Rails namespaces from project structure

Modules implied by the Rails project structure are now recognized as namespaces.

# app/models/admin/user.rb
class Admin::User < ApplicationRecord
end
            

In this example, the Admin namespace is detected and treated as a regular module.

Rename refactoring is not available in this case because the module originates from the directory structure rather than an explicit Ruby declaration.

Symbols from RBS type signatures

Symbols defined in RBS type signature files are now incorporated into code insight.

# main.rb
Book.new.read

# book.rbs
class Book
  include Readable
end

module Readable
  def read: -> untyped
end
            

Symbols such as Book and Readable are recognized from RBS and included in the model.

Class and module aliases

Aliases referring to dynamically created classes and modules are now tracked by the IDE.

ClassAlias = Class.new do; end
ModuleAlias = Module.new do; end

class Example < ClassAlias
  include ModuleAlias
end
            

Such aliases are recognized as class and module symbols and used in relevant contexts, including superclass declarations and include calls.

Performance improvements

The new modeling engine improves the performance of several code insight features.

Completion benchmarks

Qualified first-element constant completion: about 40% faster
Total constants completion time: about 50% faster
Type-matched completion (exceptions): about 95% faster

Find Usages benchmarks

Large project test cases: about 60% faster
Typical scenarios: about 15% faster

20 March 2026