RustOwl

RustOwl is a tool designed to visualize ownership movement and lifetimes of variables in Rust code. It helps with debugging and optimization by providing visual feedback through underlines when you hover over variables or function calls in supported editors.

Visual Indicators:

• 🟩 Green: Variable's lifetime
  • Definitely live: Variable is provably initialized on every path.
  • Maybe live (wavy): Variable is initialized on some paths but may have been moved, dropped, or be uninitialized on others.
• 🟦 Blue: Immutable borrowing
• 🟪 Purple: Mutable borrowing
• 🟧 Orange: Value moved or function call
• 🟥 Red: Lifetime error (e.g., diff between actual and expected lifetime, or invalid overlapped mutable/shared references).

To use RustOwl with Neovim, you must first install the RustOwl LSP server manually.

Below is a minimal setup using the lazy.nvim plugin manager:

{
  'cordx56/rustowl',
  version = '*', -- Latest stable version
  build = 'cargo install rustowl',
  lazy = false, -- This plugin is already lazy
  opts = {},
}

To use RustOwl with Emacs, you must first install the RustOwl LSP server manually.

Using Elpaca:

(elpaca
  (rustowl
    :host github
    :repo "cordx56/rustowl"))

Using use-package:

(use-package rustowl
  :after lsp-mode)

To begin using RustOwl, follow these steps:

1. Install the RustOwl LSP server and the corresponding extension for your editor (refer to docs/installation.md).
2. Open a Rust Cargo workspace in your editor.
3. Open a Rust source file (.rs).
4. Place your cursor on a variable or function call and wait for a short idle time to see the ownership and lifetime visualizations.

To use RustOwl in VS Code, install the extension from the Marketplace or Open VSX. The extension automatically downloads and runs the rustowl binary upon activation.

1. Install the extension in VS Code.
2. Open a Rust Cargo workspace.
3. Save a Rust file and hover over a variable after a short idle time to see decorations.

The fastest way to install RustOwl is by using the official installation script. This is the recommended method for a quick setup.

curl -L https://raw.githubusercontent.com/cordx56/rustowl/refs/heads/main/scripts/installer | sh

RustOwl uses a rust-toolchain.toml file to automatically manage the required nightly compiler version. For standard development (building, testing, or installing), you can use standard cargo commands.

Building with Stable Rust (for rustowlc component)

To distribute release binaries, the rustowlc component is compiled using the stable Rust compiler. This requires setting the RUSTC_BOOTSTRAP=1 environment variable.

Note: Using this method is officially discouraged; refer to the Unstable Book for details.

To build using the toolchain specified in the project's channel file, use the provided automation script:

./scripts/build/toolchain cargo build --release

Or manually (replace 1.89.0 with the desired version):

RUSTC_BOOTSTRAP=1 rustup +1.89.0 run cargo build --release

To use RustOwl in Emacs, you must first install the rustowl executable (refer to docs/installation.md). Then, install the Emacs package using either elpaca or use-package.

Once installed, open a Rust Cargo workspace. By default, placing your cursor on a variable and waiting for the timeout (2.0 seconds) will display overlays showing lifetime and borrow information.

; Elpaca example
(elpaca
  (rustowl
    :host github
    :repo "cordx56/rustowl"))

; Use-package example
(use-package rustowl
  :after lsp-mode)

Windows users can install RustOwl using the Windows Package Manager (winget).

winget install rustowl

To use RustOwl in VS Code or Vscodium, follow these steps:

1. Prerequisites:
   • Install cargo (via rustup).
   • Install VS Code or Vscodium.
2. Installation:
   • VS Code: Install the extension from the VS Code Marketplace.
   • Vscodium: Install the extension from Open VSX.
3. Activation:
   • RustOwl is installed automatically when the extension is activated.
   • In Vscodium, the extension runs automatically when you save any Rust program in a cargo workspace.
   • The initial analysis may take time, but subsequent runs use compile caching to speed up analysis.