# Meteor

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

> **TL;DR**
> Required plugins:
>
>
>
> `JavaScript and TypeScript` -    the plugin is bundled with RubyMine and enabled by default.
>
>
>
> `Meteor`, `Handlebars/Mustache` -    install the plugins on the Settings | Plugins page.

[Meteor](https://www.meteor.com/) is a full-stack framework that lets you use JavaScript both on the client-side and on the server-side. RubyMine integrates with Meteor so you can use it from inside the IDE. Meteor support in RubyMine includes:

* Automatic recognition of Meteor projects by detecting the `.meteor` folder and excluding the `.meteor/local` folder from the project. For more information, refer to [Hiding excluded files](#ws_meteor_hide_excluded_files_in_meteor_local).

* Attaching the predefined Meteor library to the project automatically. This enables syntax highlighting, resolving references, and code completion.

* Support of Spacebars via Handlebars with completion for if and each directives. RubyMine recognizes Spacebars templates, but as a side effect marks HTML files in Meteor projects with ![the Handlebars/Mustache icon](https://resources.jetbrains.com/help/img/idea/2026.3/fileTypeHandlebars.png). RubyMine provides navigation between JavaScript source code and templates with [go to Declaration](null) `Ctrl+B` (Windows), `⌘ B` (macOS), `⌘ B` (IntelliJ IDEA Classic (macOS)), `⌘ B` (macOS System Shortcuts), `Ctrl+B` (XWin), `Ctrl+B` (GNOME), `Ctrl+B` (KDE), `Ctrl+Alt+G` (Emacs), `F12` (Sublime Text), `F12` (Sublime Text (macOS)), `F12` (Visual Studio), `F12` (Visual Studio (macOS)), `Meta+B` (TextMate), `Ctrl+B` (NetBeans), `F3` (Eclipse), `F3` (Eclipse (macOS)).

* A dedicated complex Meteor run/debug configuration for debugging both the client-side and the server-side code within one debugging session, refer to [Debugging a Meteor application](#ws_meteor_debugging).

## Before you start

Procedure:

1. Download and install [Node.js](http://nodejs.org/#download).

2. Make sure the  JavaScript and TypeScript plugin is enabled in the 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 `Plugins`.  In the search field, type JavaScript and TypeScript. For more information about plugins, refer to [Managing plugins](managing-plugins.html).

3. Install the Meteor and Handlebars/Mustache plugins on the Settings | Plugins page, as described in [Installing plugins from
JetBrains Marketplace](managing-plugins.html#install_plugin_from_repo).

## Install Meteor

The installation procedure depends on the operating system you are using. Learn more from the [Meteor official website](http://docs.meteor.com/).

Windows:

Procedure:

* Download the `LaunchMeteor.exe` installer at the [Meteor official website](https://www.meteor.com/install).

macOS:

> **Note:**
> Make sure you are using macOS 10.6 or later.

Procedure:

* In your command-line shell or in the embedded Terminal (`Alt+F12` (Windows), `⌥ F12` (macOS), `⌥ F12` (IntelliJ IDEA Classic (macOS)), `⌘ ⌃ T` (macOS System Shortcuts), `Alt+F12` (XWin), `Alt+F12` (GNOME), `Alt+F12` (KDE), `Alt+F12` (Emacs), `Alt+F12` (Sublime Text), `⌥ F12` (Sublime Text (macOS)), `Ctrl+Alt+1` (Visual Studio), `⌘ ⌃ 1` (Visual Studio (macOS)), `Alt+F12` (TextMate), `Alt+F12` (NetBeans), `Alt+F12` (Eclipse), `⌥ F12` (Eclipse (macOS))) , type:

`$ curl https://install.meteor.com | /bin/sh`

Linux:

Procedure:

* In your command-line shell or in the embedded Terminal (`Alt+F12` (Windows), `⌥ F12` (macOS), `⌥ F12` (IntelliJ IDEA Classic (macOS)), `⌘ ⌃ T` (macOS System Shortcuts), `Alt+F12` (XWin), `Alt+F12` (GNOME), `Alt+F12` (KDE), `Alt+F12` (Emacs), `Alt+F12` (Sublime Text), `⌥ F12` (Sublime Text (macOS)), `Ctrl+Alt+1` (Visual Studio), `⌘ ⌃ 1` (Visual Studio (macOS)), `Alt+F12` (TextMate), `Alt+F12` (NetBeans), `Alt+F12` (Eclipse), `⌥ F12` (Eclipse (macOS))) , type:

`$ curl https://install.meteor.com | /bin/sh`

## Create a new Meteor application

If you have no application yet, you can generate a RubyMine project with Meteor-specific structure from a Meteor boilerplate template. Alternatively, create an empty RubyMine project and configure Meteor support in it as described in [Starting with an existing Meteor application](#ws_meteor_configure_meteor_support_in_existing_project) below.

Procedure: Create a Meteor project from a boilerplate template

1. Click New Project  on the Welcome screen or select  `File | New | Project`   from the main menu. The [New Project dialog](null) opens.

2. In the left-hand pane, choose Meteor.

3. In the right-hand pane:

1.

Specify the path to the folder where the project-related files will be stored.

2.

Specify the location of the Meteor executable file (refer to [Installing Meteor](#installMeteor)).

3.

From the Template list,  choose the sample to generate. To have a basic project structure generated, choose the Default option.

4.

In the Filename field,  type the name for the mutually related `.js`, `.html`, and `.css` files that will be generated. The field is available only if the Default sample type is selected from the Template drop-dow list.

Procedure: Create an empty RubyMine project

1. Click New Project  on the Welcome screen or select  `File | New | Project`   from the main menu. The [New Project dialog](null) opens.

2. In the left-hand pane, choose Empty Project . In the right-hand pane, specify the application folder and click Create.

## Start with an existing Meteor application

If you are going to continue developing an existing Meteor application, open it in RubyMine, configure Meteor in it, and download the required dependencies as described in [Downloading Meteor dependencies](#ws_meteor_download_dependencies) below.

Procedure: Open the application sources that are already on your machine

* Click Open on the Welcome  screen or select `File | Open`   from the main menu. In the dialog that opens, select the folder where your sources are stored.

Procedure: Check out the application sources from your version control

1. Click Clone Repository on the Welcome  screen.

Alternatively, select  `File | New | Get from Version Control` or  `Git | Clone…` or `VCS | Get from Version Control` from the main menu.

Instead of Git in the main menu, you may see any other Version Control System that is associated with your project. For example, Mercurial or Perforce.

2. In the dialog that opens, select your version control system from the list and specify the repository to check out the application sources from. For more information, refer to [Check out a
project (clone)](manage-projects-hosted-on-github.html#clone-from-GitHub).

Procedure: Configure Meteor support in an existing project

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 `Languages & Frameworks | JavaScript | Meteor`. The [Meteor](meteor-page.html) page opens.

2. Specify the path to the Meteor executable file. If you followed the standard installation procedure, RubyMine detects the file automatically.

3. To involve the `.meteor/local` folder and its contents in project analysis, clear the Automatically exclude ".meteor/local" directory on open project checkbox. For more information, refer to  [Hiding excluded files](#ws_meteor_hide_excluded_files_in_meteor_local) below.

4. Make sure the Automatically import Meteor packages as external library checkbox is selected.

* When the checkbox is selected, RubyMine automatically imports the external packages from the `meteor/packages` file. As a result, RubyMine provides full range coding assistance: resolves references to Meteor built-in functions, for example, `check(true)`, and to functions from third-party packages, provides proper syntax and error highlighting, supports debugging with source maps, and so on.

* When this checkbox is cleared, RubyMine does not automatically import the external packages from the `meteor/packages` file. As a result no coding assistance is provided. To improve the situation, open the `meteor/packages` file in the editor and click the Import packages as library link or run the `meteor --update` command.

5. Make sure RubyMine has attached the Meteor library to the project.

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 `Languages & Frameworks | JavaScript | Libraries`.

2.

On the Settings: JavaScript Libraries page that opens, make sure the checkbox next to the Meteor project library in the Libraries list is selected.

### Project security

When you open a project that was created outside RubyMine and was imported into it, RubyMine displays a dialog where you can decide how to handle this project with unfamiliar source code.

Select one of the following options:

* Preview in Safe Mode: in this case, RubyMine opens the project in a preview mode. It means that you can browse the project's sources but you cannot run tasks and script or run/debug your project. RubyMine displays a notification on top of the editor area, and you can click the Trust project… link and load your project at any time.

* Trust Project: in this case, RubyMine opens and loads a project. That means the project is initialized, project's plugins are resolved, dependencies are added, and all RubyMine features are available.

* Don't Open: in this case, RubyMine doesn't open the project.

Learn more from [Project security](project-security.html).

> **Tip:**
> Projects created from the Welcome screen or via `File | New | Project`  as described in  are automatically considered trusted.

## Import Meteor packages

Besides the predefined Meteor library that ensures basic Meteor-specific coding assistance, you can download additional [packages](http://docs.meteor.com/#/basic/packages) that are defined in the `.meteor/local/packages` file.

Procedure: Download additional Meteor packages

1. Open the `.meteor/local/packages` file in the editor.

2. Click the Import Meteor Packages link in the upper right-hand corner of the screen.

3. In the dialog that opens, specify the packages to download depending on the type of the application you are going to develop in your project.

* Client

* Server

* Cordova: select this option to import the packages that support development of Meteor applications for iOS and Android For more information, refer to [Meteor Cordova Phonegap Integration](https://github.com/meteor/meteor/wiki/Meteor-Cordova-Phonegap-integration).

RubyMine automatically marks the `.meteor/local` folder, which is intended for storing the built application, as excluded but still shows it in the project tree.

> **Tip:**
> Folders and files marked as excluded are not used in code completion.

Procedure: Hide the .meteor/local folder

* Click the ![Show Options Menu](https://resources.jetbrains.com/help/img/idea/2026.3/icon_viewMode.png) button on the toolbar of the   Project tool window  (`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)))  and remove a tick next to the Show Excluded Files option.

## Run a Meteor application

RubyMine runs Meteor applications according to a run configuration of the type [Meteor](null). If you created your application from a boilerplate template, RubyMine generates this run configuration for you.

Procedure: Create a Meteor run configuration

1. Select Edit Configurations from the Run/Debug Configurations widget on the toolbar, click the Add New Configuration button (![the Add New Configuration button](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.general.add.svg)) and select Meteor from the list to open the [configuration settings](null).

![Start creating a run/debug configuration](https://resources.jetbrains.com/help/img/idea/2026.3/createRunDebugConfig_Start.animated.gif)

2. In the Configuration tab, specify the path to the Meteor executable file according to the installation (refer to [Installing Meteor](#installMeteor)).

3. Specify the folder under which the application files to run are stored. This folder must have a `.meteor` subfolder in the root so RubyMine recognizes your application as a Meteor project.

By default, the working directory is the project root folder.

> **Tip:**
> Technically, RubyMine creates separate run configurations for the server-side and the client-side code, but you specify all your settings in one dedicated Meteor run configuration.

Procedure: Optionally

1. In the Program Arguments field,  specify the command-line additional parameters to be passed to the executable file on start up, if applicable. These can be, for example, `--dev`, `--test`, or `--prod` to indicate the environment in which the application is running (development, test, or production environments) so different resources are loaded on start up.

2. By default, RubyMine shows the application output in the Run tool window. To view the results of the client-side code execution, in the Browser / Live Edit tab select the Launch Browser checkbox and choose the browser to open from the list. In the field below, specify the URL address to open the application at. The default value is `http://localhost:3000`.

Procedure: Run a Meteor application

1. [Create a run/debug configuration as
described above](#meteor_create_run_config) or modify an existing one and click  Run in the dialog.

Alternatively,   select the newly created run configuration from the list on the main toolbar and click ![the Run button](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.run.run.svg).

2. View the application output in the Run tool window or in the browser if you configured the browser to open on application start [as described above](#ws_meteor_run_config_open_browser).

## Debug a Meteor application

With RubyMine, you can debug both the client-side and the server-side of Meteor JavaScript code within one debugging session. A debugging session is initiated only through a dedicated Meteor run configuration.

Technically, several Meteor projects that implement different applications can be combined within one single RubyMine project. To run and debug these applications independently, create a separate run configuration for each of them with the relevant working directory. To avoid port conflicts, these run configurations should use different ports. In the Program Arguments field, specify a separate port for each run configuration in the format `--port=<port_number>`.

> **Note:**
> Debugging of JavaScript client-side code is only supported in [Google Chrome](http://www.google.com/chrome/) and in other [Chromium-based browsers](https://www.chromium.org/).

Procedure:

1. Set the [breakpoints](using-breakpoints.html) in the code where necessary.

> **Tip:**
> The debugger also pauses at the breakpoints set in the sources stored in the `/packages` folder. This functionality is supported both for the client side and for the server side code.

2. Create a Meteor run/debug configuration [as described above](#meteor_create_run_config). In the Browse / Live Edit tab, select the Launch Browser checkbox, choose Chrome from the list, and select the Start JavaScript debugger after launch checkbox.

3. To initiate a debugging session,  select the required debug configuration from the list on the main toolbar and click ![the Debug button](https://resources.jetbrains.com/help/img/idea/2026.3/app.expui.run.debug.svg) next to the list or select `Run | Debug <configuration name>` from the main menu.

The Debug tool window opens showing two tabs: one for debugging the server-side code marked with ![the Meteor icon](https://resources.jetbrains.com/help/img/idea/2026.3/icon_meteor.png) and the other one for debugging the client-side code marked with ![the JavaScript icon](https://resources.jetbrains.com/help/img/idea/2026.3/icon_javascript.png).

4. [Explore the suspended program](examining-suspended-program.html) and [step through the program](stepping-through-the-program.html).

5. Optionally, preview the changes to the application on the fly [as described below](#ws_meteor_debug_preview_changes).

### Preview changes in the browser

During a debugging session, you can preview changes to your HTML, CSS, or JavaScript code on the fly. The live contents of the page you edit are shown in the `Elements` tab of the [Debug tool window](debug-tool-window.html) . The update policy depends on which part of your application you are editing.

Procedure: Preview changes to the client-side code

* Switch to the <Configuration name> JavaScript ![JavaScript icon](https://resources.jetbrains.com/help/img/idea/2026.3/icon_javascript.png) tab and click ![Update](https://resources.jetbrains.com/help/img/idea/2026.3/update_icon.png) on the toolbar.

* Configure automatic upload of updates by selecting the Enable Meteor Hot code push checkbox on the [Meteor](meteor-page.html) page. Learn more from the [Meteor official website](https://www.meteor.com/blog/2012/02/09/hot-code-pushes).

Procedure: Preview the changes to the server-side code

* Switch to the <Configuration name> ![Meteor icon](https://resources.jetbrains.com/help/img/idea/2026.3/icon_meteor.png) tab and click ![Update](https://resources.jetbrains.com/help/img/idea/2026.3/update_icon.png) on the toolbar.

* Configure automatic upload with the Live Edit functionality as described in [Live Edit in HTML, CSS, and JavaScript](live-editing.html). It is recommended that you select the Restart if hotswap fails checkbox on the page, then RubyMine will attempt to reload the page if the changes couldn't be applied without that.

> **Tip:**
> If automatic upload still fails, restart the application by clicking ![the Rerun button](https://resources.jetbrains.com/help/img/idea/2026.3/app.actions.rerun.svg) on the toolbar.

