# Frank: A Lightweight League of Legends Assistant for Tauri Users

> SYJun404/frank is an open source League of Legends assistant built with Tauri, Vue 3, Rust, and TypeScript. It provides utility views for rankings, notes, runes, teammates, and match analysis, while leaving match-history lookup to WeGame or the League mobile app.

**SYJun404/frank** — A bran-new League of Legends assistant software, a replacement for WeGame.

- Repository: https://github.com/SYJun404/frank
- Website: https://lolfrank.cn
- Stars: 1,935 · Forks: 274
- Language: TypeScript
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/syjun404-frank

## Frank's League of Legends utility scope

Frank addresses a specific gap between a basic game launcher and a full match-history service. The repository describes it as a lightweight, free, open source League of Legends assistant intended to provide convenient in-game services. Its visible interface is organized around practical player tasks rather than account administration or competitive ranking management. The source tree includes views named `home`, `rank`, `record`, `rune`, and `teammate`, plus separate windows for match analysis, recent match details, and the user's own match history.

The README also draws a firm boundary around functionality. According to the project description, Frank no longer provides match-history lookup because of official requirements. Readers who need that data are directed to WeGame or the 掌上英雄联盟 app. This is a material product limitation, not a missing implementation detail that can be inferred from the directory names alone. The `queryMatch` and `recentMatch` directories therefore should not be interpreted as evidence that the current release restores a full history service.

Frank is positioned for players who want a separate desktop helper for league-related information and configuration. The project says it does not encourage or support behavior that violates Riot or Tencent rules, and it describes itself as a fair-play assistant. That stated boundary is important when assessing adoption, because an assistant that interacts with a game client can raise questions about permitted automation and client access. The README does not enumerate every action Frank performs, so the supported behavior should be confirmed against the current interface and documentation before installation is treated as approval for any particular workflow.

## Tauri, Vue 3, Rust, and the LCU connection

Frank uses a desktop application structure rather than presenting itself as a browser-only page. The documented stack combines Rust, Tauri, Vue 3, TypeScript, and TailwindCSS. The repository layout separates the frontend and native application layers: `src` contains the Vue application, while `src-tauri` contains Rust entry points and the LCU-related code. `src-tauri/src/lib.rs` and `src-tauri/src/main.rs` provide the native entry area visible from the repository description. The `src-tauri/src/shaco` directory is identified as the library used to connect to the LCU, with additional LCU code in `src-tauri/src/lcu` and `src/lcu`.

The resulting data flow is split across the interface and native boundary. Vue views handle screens such as rankings, notes, runes, and teammate data. The Rust side provides the Tauri host and exposes the connection path to the League Client Update interface. The README does not provide the exact LCU endpoint list, event names, authentication procedure, or data transformation rules, so those details cannot be confirmed from the repository files alone. That omission matters to an adopter who needs to know how the application discovers the client, handles connection failures, or handles an unavailable LCU session.

The package configuration shows that the frontend uses Vue 3.5, Vite 6, TypeScript, Vue Router, Pinia, Naive UI, and TailwindCSS. Tauri packages are present for the API, opener, process, window state, HTTP, shell, global shortcuts, and CLI. These dependencies explain the application shell and its likely integration points, but dependency names alone do not prove that every plugin is active in every view. Based on the repository layout, the project has separate UI windows for background logic, main navigation, match analysis, recent matches, and query results rather than a single long-lived page.

## Installing Frank and starting a development build

The README provides a source-based development path. It first clones the repository, then its commands enter `src` before running `pnpm install`. Because the repository's documented command sequence is reproduced exactly below, the unusual path sequence is worth checking against the checkout before using it as a copy-and-paste workflow.

Clone the repository and install the frontend dependencies:

```bash
git clone https://github.com/SYJun404/frank.git
cd src
pnpm install
```

The repository also contains `src-tauri`, which is where the Rust and Tauri native components are located. The README then returns to the repository root for the development command:

```bash
cd src-tauri # 安装rust所需要的组件
cd..
pnpm run tauri dev
```

The `pnpm run tauri dev` command starts the development workflow defined by the `tauri` script in `package.json`, which delegates to Tauri. The package file also defines `pnpm run tauri build` for building the desktop application. The README does not state the required Rust version, operating systems, system dependencies, League client installation requirements, or any environment variables, so those details cannot be filled in safely here. The visible `pnpm-lock.yaml` and `pnpm-workspace.yaml` files indicate a pnpm workspace setup, but the README does not provide additional workspace instructions.

## The visible Frank interface and its data boundaries

The directory names provide a useful map of the current product surface. The `rank` view is for hero data rankings, while `record` is described as a ranked-game notes view. `rune` is for rune configuration, and `teammate` is for teammate data. A separate `home` view provides the main landing area. Match analysis and recent match detail functionality are assigned their own windows, which suggests that the application uses multiple UI surfaces for different kinds of information.

This structure creates a clear distinction between configuration, observation, and research. Rune configuration is user-facing setup work. Rank and teammate views are information displays. Notes provide a place for records that the player wants to retain. Match analysis, recent match details, and query match windows imply that some match-related display or analysis remains in the codebase, but the README expressly says that the product no longer offers match-history lookup. It would be inaccurate to promise that Frank can replace WeGame's history feature.

The frontend's visible dependencies include `pinia` for shared state and `vue-router` for navigation, although the README does not describe their exact state shape or routes. The repository also includes `src/background`, indicating a background logic window, and `src-tauri` native code for the desktop host. This arrangement is useful for engineers evaluating the architecture, but it does not establish whether data is stored locally, cached, or retrieved through an external service. The repository contains no documented schema, API contract, privacy statement, or storage policy. Those are open evaluation points, especially for a tool that displays player and teammate information.

## Licence, maintenance, and upgrade considerations

The repository is identified as MIT licensed. That licence permits use and modification under its terms, but the licence text itself is not included in the README excerpt, so this review does not interpret its obligations or give legal advice. The top-level `LICENSE` file is present, and adopters should read that file alongside any policy or distribution requirements relevant to their intended use.

The repository is not archived. Its last push was on 2026-08-16, which is within the six-month period used to assess current maintenance status from the repository facts. That supports calling the repository not archived and recently pushed, but it does not prove that every feature is stable or that release support is ongoing. The latest listed release is `Frank3.0 (Frank 3.11.2502)`, dated 2025-01-08. The package version in `package.json` is `3.27.1615`, while the release list includes older entries. The source therefore carries multiple version labels, and users should identify which version they are actually building rather than assuming the release list and package manifest describe the same artifact.

An upgrade can involve the frontend dependency graph, the Tauri native layer, Rust tooling, and compatibility with the League client connection. The README does not provide an upgrade procedure, migration guide, rollback instructions, or supported version matrix. It also does not state whether LCU behavior changes require code changes. For these reasons, the project is suitable for source inspection and development, but maintenance planning requires checking `package.json`, `pnpm-lock.yaml`, and `src-tauri` directly at the revision being adopted.

## Frank versus WeGame for match-history needs

Frank's clearest alternative is WeGame, although the two products are not described as equivalent. WeGame is the service named by the README when a player needs match-history lookup. Frank instead presents a separate open source assistant interface with utility views such as rune configuration, hero rankings, notes, and teammate data. The difference is therefore scope and implementation model, not merely branding.

WeGame serves as the README's recommended destination for a specific need that Frank no longer covers. A player who primarily wants to query historical match records should use WeGame or the 掌上英雄联盟 app rather than infer that Frank's `queryMatch` directory changes the product boundary. A player who wants to inspect or build the local Tauri, Vue 3, Rust, and TypeScript assistant may find Frank more relevant, subject to compatibility requirements that the README leaves unspecified.

The alternative also helps identify the wrong tool. Frank is not presented as a full replacement for every WeGame function. Its own README says it is a fair-play assistant and deliberately removes match-history lookup. Engineers should therefore compare the requested feature against Frank's visible views and the current LCU integration rather than evaluating it as a general League of Legends platform.

## Practical limits of the documented Frank workflow

The largest practical limitation is missing operational documentation. The README does not explain how to configure the League client connection, how the LCU library handles authentication, what permissions are required, or what happens when the client is closed or unavailable. It also does not document platform support, packaging targets, release download locations beyond the project homepage link, or a rollback path. The absence of those details does not show that they are absent from the code. It means they are not confirmed by the README or repository entries available for review.

There is also a distinction between source availability and end-user support. The repository is open source and includes a native Tauri layer, but the README does not describe an issue-response process, compatibility policy, or stable channel. A game-client integration can also change independently of the repository. Based on the LCU-oriented directories, users should expect the main technical risk to sit at the boundary between the desktop application and the installed League client, although the exact failure modes are not documented.

For a first real use, start with `pnpm run tauri dev` only after following the repository's documented setup path and confirming the local toolchain. The first useful validation is not a claim about match history. It is whether the application opens its main interface and whether the LCU-dependent views can connect in the intended local environment. If those checks fail, the current documentation does not provide enough information to diagnose the cause without inspecting the Tauri logs and native source.

## Conclusion

Adopt Frank when you want to inspect and configure League-related utility views in a desktop application built from source. Do not adopt it as a replacement for match-history services, because the README explicitly excludes that function. Verify first that your local environment supports the Tauri development workflow, that the LCU connection works with your installed League client, and that the features you need are present in the current source tree.

## FAQ

### How do I install Frank from source?

The README instructs users to clone the repository, enter `src`, run `pnpm install`, then use `pnpm run tauri dev` from the repository root after moving through `src-tauri`. The exact environment prerequisites are not documented.

### Does Frank provide match-history lookup?

No. The README states that Frank no longer provides match-history lookup and directs users who need that feature to WeGame or the 掌上英雄联盟 app.

### What does Frank's LCU integration connect to?

The repository identifies `src-tauri/src/shaco` as a library for connecting to the LCU and includes LCU code in both the native and frontend source trees. The README does not document the endpoint or authentication details.

### What features are visible in Frank's interface?

The source tree lists views for hero rankings, ranked-game notes, rune configuration, teammate data, and a home view. It also contains separate windows for match analysis and recent match details, although the README excludes match-history lookup.

## Sources

- [License: MIT](https://github.com/SYJun404/frank/blob/frankrust/LICENSE)
- [Project website](https://lolfrank.cn)
- [README](https://github.com/SYJun404/frank/blob/frankrust/README.md)
- [Releases](https://github.com/SYJun404/frank/releases)
- [SYJun404/frank on GitHub](https://github.com/SYJun404/frank)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/syjun404-frank