Skip to main content

​
System Requirements

Before installing FastSkill, ensure your system meets these requirements:
ComponentMinimum VersionRecommended
Rust1.701.75+ (only needed for source builds)
Memory512MB2GB+
Storage100MB500MB+
OpenAI API KeyRequiredFor embedding features
For binary installation, you don’t need Rust installed. Rust is only required if building from source.

​
CLI Installation

The FastSkill CLI is a Rust-based command-line tool for managing skills. Skills Directory Resolution: The CLI automatically discovers the skills directory in this priority order:
  1. skills_directory setting in .fastskill/config.yaml
  2. Walk up directory tree to find existing .claude/skills/
  3. Default to .claude/skills/ in current directory
Manifests and lockfiles:
  • Declare skills in skill-project.toml at project root (with [dependencies] section)
  • Install with fastskill install (use --without/--only for groups)
  • Lockfile is written to skills.lock at project root after installs
  • Repository configuration is stored in [tool.fastskill.repositories] section of skill-project.toml

​
Rust Library Installation

​
Using Cargo

Add FastSkill to your Cargo.toml: 
[dependencies]
fastskill = { version = "0.1.0", features = ["git-support"] }
tokio = { version = "1.0", features = ["full"] }
Install dependencies: 
cargo build
Verify installation:
cargo check --package fastskill

​
From Source

1

Clone and setup

git clone https://github.com/gofastskill/fastskill.git
cd fastskill/rust
2

Build the project

cargo build --release
Test the build:
cargo test
3

Install system-wide (optional)

cargo install --path . --bin fastskill

​
Configuration

After installation, configure FastSkill by creating .fastskill/config.yaml: 
embedding:
  openai_base_url: "https://api.openai.com/v1"
  embedding_model: "text-embedding-3-small"

# Optional: Custom skills directory
skills_directory: ".claude/skills"
Note: Service-level configuration (embedding settings) is stored in .fastskill/config.yaml. Project-level configuration (skill dependencies and repositories) is stored in skill-project.toml at your project root. Set your OpenAI API key: 
export OPENAI_API_KEY="your-key-here"

​
Docker Installation

​
Building from Source

1

Clone the repository

git clone https://github.com/gofastskill/fastskill.git
cd fastskill
2

Build Docker image

# Build Rust image
docker build -f docker/rust/Dockerfile -t fastskill-rust .
3

Run the container

docker run -it fastskill-rust ./target/release/fastskill --help

​
Development Setup

For contributors and advanced users:
1

Install Rust toolchain

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
2

Install development tools

cargo install cargo-watch cargo-audit cargo-udeps
rustup component add rustfmt clippy
3

Setup development environment

cd tools/fastskill/rust
cargo build
4

Run tests and checks

cargo test
cargo fmt --check
cargo clippy -- -D warnings
cargo audit

​
Platform-Specific Instructions

​
macOS

# Using Homebrew (optional, Rust can be installed via rustup)
brew install rust

# Or use rustup (recommended)
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
cargo install fastskill --features git-support

​
Linux

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source ~/.cargo/env
cargo install fastskill --features git-support

​
Windows

# Install Rust using rustup-init.exe from https://rustup.rs/
# Follow the installation prompts

# Add Cargo to PATH (usually done automatically)
cargo install fastskill --features git-support

# Verify installation
cargo --version
fastskill --version

​
Verification

After installation, verify everything works correctly:
1

Basic functionality test

Create a test file verification.rs:
use fastskill::{FastSkillService, ServiceConfig};
use std::path::PathBuf;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🧪 Running FastSkill verification...");

    let config = ServiceConfig {
        skill_storage_path: PathBuf::from("./skills"),
        ..Default::default()
    };

    let service = FastSkillService::new(config).await?;
    service.initialize().await?;

    // Test skill listing
    let skills = service.skill_manager().list_skills(None).await?;
    println!("Found {} skills", skills.len());

    // Test skill discovery
    let relevant_skills = service.metadata_service()
        .discover_skills("test")
        .await?;
    
    println!("Found {} relevant skills", relevant_skills.len());
    println!("✅ All verification tests passed!");

    Ok(())
}
2

Run the verification

# Add to Cargo.toml temporarily or run as example
cargo run --example verification

​
Troubleshooting

Binary not found in PATH: After extracting the binary, ensure it’s in your system PATH. On Linux, try /usr/local/bin/ or ~/.local/bin/. On Windows, add the directory to your PATH environment variable.
Permission denied (Linux): If you get permission errors, use sudo when moving to /usr/local/bin/, or install to ~/.local/bin/ instead and ensure it’s in your PATH.
Windows security warning: Windows may show a security warning for unsigned binaries. Click “More info” and then “Run anyway” if you trust the source.
Rust not found (source builds only): If building from source, ensure Rust is installed and in your PATH. Run rustc --version to verify.
Cargo build errors (source builds only): Make sure you have a stable Rust toolchain: rustup install stable
Embedding configuration required: Create .fastskill.yaml with OpenAI API configuration. See Configuration Guide.
OpenAI API key not found: Set OPENAI_API_KEY environment variable or configure in .fastskill.yaml.
macOS security: If you get security warnings, go to System Settings > Privacy & Security and allow the binary.
Windows antivirus: Add an exception for the FastSkill installation directory if antivirus blocks compilation.
Linux linker errors: Install build essentials: sudo apt-get install build-essential (Ubuntu/Debian) or equivalent.
Still having issues? Check the troubleshooting section or get help from the community.