rank-analysis

---

TL;DR for developers — A native LoL client tool built with Tauri 2 + Rust + Vue 3 + TypeScript. ~5 MB installer, a single native binary on Windows and Apple Silicon macOS, zero Electron overhead. Its core is a data-driven AI match-review pipeline: every game is quantified (KDA, damage/tank share, kill participation, gold, team comp) and streamed to an LLM that tells you who carried, who fed, and who got dragged down. Talks to the LCU WebSocket for live in-game state, async Rust HTTP for match history. No DLL injection, no game memory access — uses only Riot's official local client API.

Introduction

Rank Analysis is a League of Legends companion built on Riot's official LCU API. Its standout feature is data-driven AI match review: instead of just throwing numbers at you, it quantifies each game and has an AI explain why you won or lost — who carried, who fed, who got stomped, and who was dragged down by teammates. Around that core it also covers the essentials: match-history lookup with win-rate highlighting, premade & teammate-risk detection, and rule-based auto pick/ban.

Built with Tauri 2.0, it pairs Rust's performance with a web frontend in a ~5 MB, single-binary app — no DLL injection, no memory reads, only the official local client API.

✨ Features

AI Match Review — the core

• Full Match Review: One click in the match details turns the game into a verdict — who performed best, who fed, who got stomped, and who was dragged down by teammates
• Single Player Review: Analyze any participant individually (carried / fed / stomped / dragged down / normal)
• Lobby-level Risk Assessment: During lobby/queue, assess teammate and opponent risk from recent history, favorite champions, role distribution, and tags
• Evidence-Driven, not vibes: Every verdict is grounded in real data — KDA, damage share, tank share, gold, kill participation, towers, CS — not subjective commentary
• Streaming + Cached: Results stream in token-by-token and are cached per match within the session to avoid repeated waits

Match History Query

• Win Rate Highlighting: Intuitively displays teammates' recent performance
• MVP Display: Quickly identify carry players
• Player Tags: Auto-tags win streaks, loss streaks, and non-ranked players
• Relationship Display: Identifies nemeses and friends

Match Analysis

• Premade Detection: Marks pre-grouped players (duo/squad detection)
• Match History: Marks previously encountered players
• Match Details Panel: Independent window showing 10 players' KDA, economy, CS, damage taken, towers destroyed, items, skills, and runes/augments
• Augment Recognition: Special queues like Arena automatically switch to augment display with rarity differentiation

Automation Assistant

• Auto Matchmaking: Automatically starts searching for matches
• Auto Accept: Automatically accepts matches when found
• Rule-based Pick/Ban: A configurable rule engine picks/bans by role × ally/enemy champion conditions (falls back to a fixed preset list)

️ Notes, Tags & Data Sync

• Player Notes: Leave a note + color label (friendly / normal / careful / blacklist) on players you meet — surfaced automatically next time you run into them
• Tag Management: A dozen toggleable behavior tags (win streak, loss streak, smurf suspect, hot streak, slump...), with AI-suggested personalized tags based on your recent history
• Cloud Sync & Backup: Player notes and full config sync across devices (last-write-wins merge), plus one-click JSON export/import

Screenshots

AI Full-Match Review — a one-line verdict plus who carried / who fed / who got stomped, every call backed by real numbers

Match History — look up any summoner, dark / light theme

Live Match Analysis — recent records, rank, tags and premade detection for all 10 players, automatically on game start

Match Details — a dedicated window with per-player KDA / gold / damage, plus one-click AI review

Player Notes & Tag Management

Automation & General Settings

Backup & Cloud Sync

Usage

1. Download:

   • GitHub Releases (primary): grab the latest build from the Release Page
   • GitCode mirror (faster in mainland China): download from GitCode Releases

   System Requirements

   • Windows: Windows 10 1803 or higher (WebView2 support required)
   • macOS: macOS 10.15 or higher, Apple Silicon only (*-macos-aarch64.dmg; no Intel build)

   Feature parity: everything that runs off the LCU API — match history, AI review, premade detection, auto accept/pick/ban, cloud sync — works the same on both platforms. Two helpers are Windows-only because they have no macOS equivalent: launch LoL without WeGame (relies on the Tencent launcher's Windows install layout) and relaunch as administrator (macOS has no UAC). The app hides both on macOS rather than showing buttons that would always fail.

2. Run: Extract and run the executable directly - no admin privileges required

   macOS first launch: the app is ad-hoc signed but not notarized (Apple notarization requires a paid Developer account). macOS will refuse the first launch. Open System Settings → Privacy & Security, scroll to the bottom and click Open Anyway next to the blocked app, then launch it again. This is only needed once.

3. Connect: The software automatically detects the game client when running

   Notes:

   • Currently only supports Tencent servers (China)
   • Can be opened mid-game and will auto-connect
   • AI analysis requires internet access to call model services; network unavailability only affects AI features, not basic match history queries

️ Development & Build

If you want to compile this project yourself, follow these steps:

Prerequisites

• Node.js (LTS version recommended)
• Rust
• A native toolchain:
  • Windows: Visual Studio C++ Build Tools
  • macOS: Xcode Command Line Tools (xcode-select --install)

Both platforms build from the same source tree. npm run tauri build produces an NSIS installer on Windows; on macOS pass the bundle target explicitly, since tauri.conf.json defaults to nsis:

npm run tauri build -- --bundles dmg

Build Steps

1. Clone and enter the Tauri directory:

   cd rank-analysis-app
   

2. Install dependencies:

   npm install
   

3. Run in development mode:

   npm run tauri dev
   

4. Build production version:

   npm run tauri build
   

   The executable will be located in src-tauri/target/release/bundle

Code Quality

This project uses modern development toolchain to ensure code quality and consistency:

Quality Tools

• ESLint: Static code analysis
• Prettier: Code formatting
• TypeScript: Strict type checking
• Clippy: Rust code linting
• Rustfmt: Rust code formatting
• GitHub Actions: Automated CI/CD

Quality Check Commands

cd rank-analysis-app

# One-shot gate — runs before every commit (mirrors CI exactly)
npm run check         # format + lint + typecheck + cargo fmt --check + clippy --all-targets --all-features -Dwarnings
npm run test          # vitest

# Individual steps (if you want to run them piecemeal)
npm run lint          # ESLint
npm run format        # Prettier
npm run typecheck     # vue-tsc
cd src-tauri && cargo fmt --all -- --check && cargo clippy --all-targets --all-features -- -Dwarnings

npm run check is the canonical pre-commit gate. It matches the flags used by .github/workflows/quality-checks.yml — if it passes locally, CI will pass.

For detailed code quality standards and contribution guidelines, please refer to:

• Code Quality Standards
• Contributing Guide

Contributing

Issues and Pull Requests are welcome!

• Bug Reports: Submit via GitHub Issues
• Code Contributions: Improvements and new features are welcome

License

This project is open-sourced under the MIT License.

Maintained with AI assistance experiments (Claude / LLM tooling)

Star History