Rust Language Support

Glass provides first-class Rust support through rust-analyzer integration, offering advanced IDE features, Cargo task automation, and semantic token highlighting.

LSP Server: rust-analyzer

Glass uses rust-analyzer as the language server for Rust.

Installation

Automatic
System Installation

Glass automatically downloads and installs rust-analyzer if not found:

Detects your system architecture and libc type (GNU/musl on Linux)
Downloads from the rust-lang/rust-analyzer GitHub releases
Verifies SHA-256 checksums for security
Manages multiple versions in ~/.local/share/zed/languages/rust-analyzer/

The adapter will automatically use the latest compatible version.

If you have rust-analyzer installed via rustup or your package manager:

# Via rustup (recommended)
rustup component add rust-analyzer

# Via cargo
cargo install rust-analyzer

Glass will detect and use your system installation automatically. The adapter tests the binary with rust-analyzer --help to ensure it works correctly.

On Linux, Glass automatically detects whether you’re using GNU libc or musl and downloads the appropriate binary.

Features

Intelligent Completions

rust-analyzer provides context-aware completions with:

Full signatures: Function and method signatures with parameter types
Snippets: Complete function bodies with placeholders
Import suggestions: Automatic import path suggestions
Trait completions: Methods from implemented traits

Function Completion
Struct Field Completion
Snippet Completion

fn example(value: String) {
    value.to_| // Completes to to_uppercase() with full signature
}

Glass displays: to_uppercase() -> String

struct Point { x: f64, y: f64 }

let p = Point {
    x: 1.0,
    y| // Suggests y with type information
};

Completion shows: y: f64

impl MyTrait for MyStruct {
    fn method| // Expands to full method signature
}

Expands to:

fn method(&self, param: Type) -> ReturnType {
    todo!()
}

Semantic Highlighting

Rust-analyzer provides semantic token information for precise syntax highlighting:

// Distinguishes between:
struct Type;        // Type (blue)
let variable = 1;   // Variable (white)
const CONSTANT: i32 = 42;  // Constant (purple)

fn function() {     // Function (yellow)
    macro_name!();  // Macro (cyan)
}

Semantic rules are defined in crates/languages/src/rust/semantic_token_rules.json.

Diagnostics

Glass displays diagnostics from both rust-analyzer and cargo:

Compiler Errors
Cargo Check

fn example() {
    let x = "hello";
    x.push('!');  // Error: no method named `push` found
}

Diagnostics include:

Error message with help text
Related information (like trait imports needed)
Quick fixes (code actions)

Real-time diagnostics from cargo check:

Runs in the background
Shows errors across the entire workspace
Progress indicator: rust-analyzer/flycheck

Glass processes cargo diagnostics with the source name cargo.

Glass processes diagnostics to clean up rust-analyzer’s markdown formatting (removing trailing newlines in code blocks).

Cargo Integration

Glass provides comprehensive Cargo task automation:

Available Tasks

Check & Build
Testing
Running

Check (package): cargo check -p $RUST_PACKAGE
Check all targets: cargo check --workspace --all-targets
Build: cargo build
Clean: cargo clean

Tasks use the package containing the current file.

Test specific test: cargo test -p $RUST_PACKAGE -- $RUST_TEST_NAME
Test module: cargo test -p $RUST_PACKAGE -- $RUST_TEST_FRAGMENT
Doc test: cargo test --doc -p $RUST_PACKAGE -- $RUST_DOC_TEST_NAME
Test package: cargo test -p $RUST_PACKAGE

Glass automatically detects test names and modules from your code.

Run bin/example: cargo run -p $RUST_PACKAGE --$RUST_BIN_KIND $RUST_BIN_NAME
Run default: cargo run

Automatically includes required features from Cargo.toml:

[[bin]]
name = "my-bin"
required-features = ["feature-name"]

Task includes: --features feature-name

Task Variables

Glass extracts these variables from your Rust workspace:

Variable	Description	Source
`RUST_PACKAGE`	Package name	`cargo metadata`
`RUST_BIN_NAME`	Binary target name	`Cargo.toml` targets
`RUST_BIN_KIND`	`bin` or `example`	Target kind
`RUST_BIN_REQUIRED_FEATURES_FLAG`	`--features` or empty	From manifest
`RUST_BIN_REQUIRED_FEATURES`	Comma-separated features	From manifest
`RUST_TEST_NAME`	Test function name	From symbol
`RUST_TEST_FRAGMENT`	Module test path	From file structure
`RUST_MANIFEST_DIRNAME`	Directory with `Cargo.toml`	Workspace detection

Custom Target Directory

Configure a custom target directory in language settings:

{
  "languages": {
    "Rust": {
      "tasks": {
        "variables": {
          "RUST_TARGET_DIR": "./target/custom"
        }
      }
    }
  }
}

All cargo commands will use --target-dir ./target/custom.

Configuration

Dynamic Schema

rust-analyzer’s configuration schema is dynamically loaded by running:

rust-analyzer --print-config-schema

Glass converts the schema to a nested JSON format for settings validation.

Example Configuration

{
  "lsp": {
    "rust-analyzer": {
      "initialization_options": {
        "check": {
          "command": "clippy",
          "extraArgs": ["--all-targets"]
        },
        "cargo": {
          "features": "all",
          "targetDir": true
        },
        "procMacro": {
          "enable": true
        }
      }
    }
  }
}

LSP Tasks (Experimental)

Enable rust-analyzer’s runnable tasks:

{
  "lsp": {
    "rust-analyzer": {
      "enable_lsp_tasks": true
    }
  }
}

This allows rust-analyzer to provide its own test/run tasks with:

"experimental": {
  "runnables": {
    "kinds": ["cargo", "shell"]
  }
}

Code Actions

rust-analyzer provides extensive code actions:

Import suggestions: Add missing imports
Fill match arms: Complete match expressions
Add derive: Add derive macros to structs
Extract function: Extract code to a new function
Inline: Inline variables or functions
Generate implementations: Implement traits

Workspace Detection

Glass detects your Rust workspace by finding Cargo.toml files:

// From crates/languages/src/rust.rs:CargoManifestProvider
fn search(&self, query: ManifestQuery) -> Option<Arc<RelPath>> {
    // Walks up directory tree finding Cargo.toml
    // Returns outermost manifest (workspace root)
}

For multi-package workspaces, Glass uses the outermost Cargo.toml as the workspace root.

Platform-Specific Notes

Linux

Auto-detects GNU libc vs musl
Tests with ldd --version or scans /lib directory
Downloads appropriate binary automatically

macOS

Uses apple-darwin builds
Full support for Apple Silicon (aarch64)

Windows

Downloads .zip archives with .exe binary
Uses pc-windows-msvc builds

FreeBSD

Uses unknown-freebsd builds
May require manual compilation for some architectures

Troubleshooting

Server Not Starting
Slow Performance
Workspace Issues

Check that rust-analyzer works:

rust-analyzer --version

If installed via rustup:

rustup component add rust-analyzer

Glass logs server startup in the LSP logs (Cmd/Ctrl+Shift+P → “language server: Show logs”).

For large projects, configure:

{
  "lsp": {
    "rust-analyzer": {
      "initialization_options": {
        "cargo": {
          "targetDir": true,
          "loadOutDirsFromCheck": true
        }
      }
    }
  }
}

This uses a separate target directory for rust-analyzer’s cargo checks.

For workspace crates, ensure your workspace Cargo.toml includes:

[workspace]
members = ["crate1", "crate2"]
resolver = "2"

Glass will detect the workspace root and configure rust-analyzer appropriately.

Get Started

Core Features

AI Capabilities

Development

Customization

Language Support

Rust Language Support

LSP Server: rust-analyzer

Installation

Features

Intelligent Completions

Semantic Highlighting

Diagnostics

Cargo Integration

Available Tasks

Task Variables

Custom Target Directory

Configuration

Dynamic Schema

Example Configuration

LSP Tasks (Experimental)

Code Actions

Workspace Detection

Platform-Specific Notes

Linux

macOS

Windows

FreeBSD

Troubleshooting

Next Steps

Build docs developers (and LLMs) love

Get Started

Core Features

AI Capabilities

Development

Customization

Language Support

​LSP Server: rust-analyzer

​Installation

​Features

​Intelligent Completions

​Semantic Highlighting

​Diagnostics

​Cargo Integration

​Available Tasks

​Task Variables

​Custom Target Directory

​Configuration

​Dynamic Schema

​Example Configuration

​LSP Tasks (Experimental)

​Code Actions

​Workspace Detection

​Platform-Specific Notes

​Linux

​macOS

​Windows

​FreeBSD

​Troubleshooting

​Next Steps

Build docs developers (and LLMs) love

LSP Server: rust-analyzer

Installation

Features

Intelligent Completions

Semantic Highlighting

Diagnostics

Cargo Integration

Available Tasks

Task Variables

Custom Target Directory

Configuration

Dynamic Schema

Example Configuration

LSP Tasks (Experimental)

Code Actions

Workspace Detection

Platform-Specific Notes

Linux

macOS

Windows

FreeBSD

Troubleshooting

Next Steps