# Language and reference injections

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

Language injections let you work with pieces of code in a programming language different from the main language of your file.

When you inject a language (such as HTML, CSS, XML, RegExp, and so on) into a string literal, you get comprehensive coding assistance for the injected code even though it is not the main language of your project.

In addition to language injections, the IDE also supports reference injections, which treat string literals as references to other entities , such as classes or files.

## Add language injections

Procedure: Add a temporary language injection

1. Place the caret inside the string literal, tag, or attribute, in which you want to inject a language 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)) (or use the intention action icon ![intention action icon](https://resources.jetbrains.com/help/img/idea/2026.3/app-client.expui.codeInsight.intentionBulb.svg)).

2. Select Inject language or reference and choose the language you want to inject.

![Inject an SQL query in a Ruby script](https://resources.jetbrains.com/help/img/idea/2026.3/rm_lang_injection_insert.animated.gif)

> **Tip:**
> If the Inject language or reference intention action is not available by default, go to `Settings (`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))) | Editor | Intentions` and select the Inject language or reference checkbox in the Language injection section.
>
>
>
> ![Inject language or reference checkbox](https://resources.jetbrains.com/help/img/idea/2026.3/inject_language_or_reference.png)

Procedure: Add a persistent language injection

Use language injection comments (annotations) to add persistent fragments of injected languages.

* Add a blank line before the target string literal, and type the following comment:

```SHELL
# language=<language_ID>
```

![SQL injection comment](https://resources.jetbrains.com/help/img/idea/2026.3/rm_lang_injection_comment.animated.gif)

Write the comment in the comment syntax of the file where you add it, not of the language you want to inject. A language ID can differ from the language name that RubyMine shows, for example, in the list of injectable languages.

To find the language ID, place the caret after `language=` in the comment and press `Ctrl+Space` (Windows), `⌃ Space` (macOS), `⌃ Space` (IntelliJ IDEA Classic (macOS)), `⌃ Space` (macOS System Shortcuts), `Ctrl+Space` (XWin), `Ctrl+Space` (GNOME), `Ctrl+Space` (KDE), `Alt+/` (Emacs), `Ctrl+Space` (Sublime Text), `⌃ Space` (Sublime Text (macOS)), `Ctrl+Space` (Visual Studio), `⌃ Space` (Visual Studio (macOS)), `Ctrl+Space` (TextMate), `Ctrl+Space` (NetBeans), `Ctrl+Space` (Eclipse), `⌃ Space` (Eclipse (macOS)). The completion list shows the IDs of all injectable languages with the language names in parentheses.

You can also learn language IDs in settings.  Press `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)) to open settings and then select `Editor | Language Injections`.  Double-click an injection rule for a language; the language ID is specified in the ID field.

* (Optional) Include a prefix or a suffix in your comment.

```SHELL
# language=<language_ID> prefix=<prefix> suffix=<suffix>
```

This is required if:

* The string is an incomplete/partial SQL statement

* The string is not used directly in one of our supported calls (such as `select /where)`

![Language injection with a comment containing a prefix](https://resources.jetbrains.com/help/img/idea/2026.3/rm_lang_injection_comment_marker.png)

Procedure: Inject a language using a heredoc string

In the Ruby context, you can inject a language inside  heredoc strings.

1. Start typing a heredoc  string and set the marker to the language ID you want to inject. Language IDs are generally intuitive, for example, SQL, RegExp, XML, HTML.

![Injecting inside heredoc](https://resources.jetbrains.com/help/img/idea/2026.3/rm_lang_injection_heredoc.animated.gif)

2. (Optional) To specify a prefix or suffix, use a language injection comment as shown in the code block below:

```RUBY
     def feed
  # language=sql prefix="select "
  following_ids = <<~SQL.squish
   followed_id from relationships
  WHERE  follower_id = :user_id
SQL
```

## Edit injected language fragments

RubyMine allows you to edit injected language fragment in a dedicated editor.

Procedure: Open the fragment editor

1. Place the caret within the injected code piece 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)) (or use the intention action icon ![intention action icon](https://resources.jetbrains.com/help/img/idea/2026.3/app-client.expui.codeInsight.intentionBulb.svg)).

2. Select Edit <language ID> Fragment.

RubyMine will open a dedicated editor section for editing the code with the injected language. This editor provides full coding assistance, including code completion, inspections, intention actions, and code style actions.

![Edit the injected SQL query in the dedicated editor](https://resources.jetbrains.com/help/img/idea/2026.3/rm_lang_injection_edit.animated.gif)

> **Note:**
> When editing your code, you can see prefixes and suffixes only in the fragment editor. They are not shown in the main editor.

## Inject a reference

Reference injections interpret string literals as links to other entities, such as files.

For example,  `resources/config.json` can be treated as a reference to a file.

Procedure: Add a temporary reference injection

1. Place the caret inside the string literal in which you want to inject a reference 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)) (or use the intention action icon ![intention action icon](https://resources.jetbrains.com/help/img/idea/2026.3/app-client.expui.codeInsight.intentionBulb.svg)).

2. Select Inject language or reference and select an option. For example, File Reference adds a link to the specified file.

Depending on the plugins you have installed, other reference options might be available.

![Inject a file reference](https://resources.jetbrains.com/help/img/idea/2026.3/rm_reference_injections.png)

Procedure: Add a persistent reference injection

Use comments to add persistent reference injections.

Add a blank line before the target string literal and type the `# language=` comment with the necessary value.

For example, `# language=file-reference` adds a reference to a file:

```RB
require 'pathname'

def print_file_path(path)
  puts "File path: #{Pathname.new(path).realpath}"
end

def main
  # language=file-reference
  print_file_path('app/views/posts/_form.html.erb')
end

main if __FILE__ == $PROGRAM_NAME

```

## Cancel injections

Procedure: Cancel a persistent language injection

To cancel a language injection, delete the comment (annotation) you used to introduce it.

Procedure: Cancel a temporary language injection

1. Place the caret at the code fragment 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)) (or use the intention action icon ![the intention action button](https://resources.jetbrains.com/help/img/idea/2026.3/app-client.expui.codeInsight.intentionBulb.svg)).

2. Select Uninject language or reference.

![Uninjecting a language](https://resources.jetbrains.com/help/img/idea/2026.3/rm_already_injected.png)

Procedure: Disable the intention action bulb icon

Do the following to hide the intention action icon ![Intention action icon](https://resources.jetbrains.com/help/img/idea/2026.3/app-client.expui.codeInsight.intentionBulb.svg)  in the editor:

1. Press `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)) to open settings and then select `Editor | General | Appearance`.

2. Clear the Show intention bulb checkbox.

3. Apply the changes and close the dialog.

## Configure rules for automatic injections

In RubyMine, there is a set of predefined rules according to which the IDE automatically injects languages in certain places in your code.

You can configure language injection rules on  the Editor | Language Injections settings page `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)) .

![Language injection settings](https://resources.jetbrains.com/help/img/idea/2026.3/rm_lang_injection_settings.png)

All pre-defined injection rules are configured for the Built-in scope. In other words, they are global (and therefore available in all RubyMine projects). Custom rules can be configured for the IDE or for one project only. To change the scope of custom injections, use the ![the Move to Project/IDE scope button](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.import.svg).

To share a custom rule through VCS, move it to the Project scope using the corresponding option on the toolbar. By doing so, you will create a new file in the `.idea` directory named `IntelliLang.xml` with your custom rules that you can place under version control.

If you do not use a VCS, you can share your rules by exporting them to XML files (click ![Export](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.export.svg) on the toolbar) and then importing them to another project.

## See also

### Reference

[Language Injections](language-injections-settings.html)

