New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Rust Heavy Performance

by veloxbase in veloxbase/veloxdb

Enforces a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of JavaScript.

MITAuto-check passedDatabases

Install Rust Heavy Performance

skills CLI
$ npx skills add veloxbase/veloxdb --skill rust-heavy-performance -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install veloxbase/veloxdb rust-heavy-performance --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/veloxbase/veloxdb.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.cursor/skills/rust-heavy-performance .claude/skills/rust-heavy-performance && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
rust-heavy-performance
GitHub stars
646
Token cost
~733 tokens
SKILL.md length
338 words
Files
1
Skills in repo
3
Repo updated
First seen
Licence
MIT

At a glance

Enforces a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of JavaScript.

  • Works in 5 steps: Add or extend an async command in… → Keep query execution and pooling logic… → Return a compact DTO to the frontend… → …
  • Changing heavy queries
  • SKILL.md covers Core rule, Rust-first implementation…, Memory efficiency guardrails and Speed guardrails, plus 3 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Rust Heavy Performance is an agent skill from veloxbase/veloxdb. Enforces a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of JavaScript. Focuses on memory efficiency, fast execution, bounded IPC payloads, and simple implementation patterns. Use when adding or changing heavy queries, transformations, diffing, parsing, exports, aggregations, or any path where performance is critical.

Its SKILL.md is about 730 tokens, which your agent loads only when the skill is triggered. It is a single SKILL.md file with no bundled scripts.

It sits in Databases. It works with Rust, Tauri, JavaScript and MySQL. The repository describes itself as: Database management, built for developers. The licence is MIT.

When your agent uses it

  • Changing heavy queries
  • Transformations
  • Any path where performance is critical

Example prompts

  • “Use the rust-heavy-performance skill to enforce a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of…”
  • “/rust-heavy-performance”

Workflow steps

5 steps, taken from the first numbered list in SKILL.md.

  1. Add or extend an async command in src-tauri/src/commands.rs.
  2. Keep query execution and pooling logic in src-tauri/src/db.rs and related Rust modules.
  3. Return a compact DTO to the frontend (already shaped for display).
  4. Call it from src/data/repositories/ using existing invoke patterns.
  5. Render in feature UI with virtualization for large result sets.

What it can do on your machine

Read from SKILL.md and the folder at commit 2ca04f2. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md.

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Rust Heavy Performance loads about 733 tokens when it runs. Until then it costs about 98 tokens; SKILL.md has 338 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~98
When it runs · the whole SKILL.md, loaded when a task matches
~733

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from veloxbase/veloxdb at commit 2ca04f2, republished under its MIT licence (© veloxbase). 338 words, ~733 tokens.

Download SKILL.mdSave it as .claude/skills/rust-heavy-performance/SKILL.md (or your agent's skills folder).
name
rust-heavy-performance
description
Enforces a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of JavaScript. Focuses on memory efficiency, fast execution, bounded IPC payloads, and simple implementation patterns. Use when adding or changing heavy queries, transformations, diffing, parsing, exports, aggregations, or any path where performance is critical.

Rust-Heavy Performance

Use this skill when a feature can become slow or memory-heavy. Prefer implementing heavy paths in src-tauri/ and keep the frontend thin.

Core rule

  • If work is CPU-heavy, row-heavy, or repeatedly recomputed, do it in Rust.
  • JavaScript/React should orchestrate UI state and rendering, not run bulk processing loops.

Rust-first implementation pattern

  1. Add or extend an async command in src-tauri/src/commands.rs.
  2. Keep query execution and pooling logic in src-tauri/src/db.rs and related Rust modules.
  3. Return a compact DTO to the frontend (already shaped for display).
  4. Call it from src/data/repositories/ using existing invoke patterns.
  5. Render in feature UI with virtualization for large result sets.

Memory efficiency guardrails

  • Use bounded reads (LIMIT, pagination, or chunked iteration), never unbounded materialization.
  • Avoid cloning large vectors/strings when references or incremental building is enough.
  • Prefer streaming/chunked processing over collecting everything at once.
  • Keep structs narrow for IPC responses; do not ship unused fields.
  • Reuse pooled database connections; avoid ad hoc new clients per action.

Speed guardrails

  • Push filtering, sorting, grouping, and aggregation down to SQL/Rust.
  • Minimize Rust<->webview payload size; serialize only what UI needs now.
  • Cache or memoize expensive Rust-side intermediate results only when reuse is likely and bounded.
  • Use async command handlers; avoid blocking I/O in command paths.

Easy-to-implement defaults

  • Start from existing command and repository patterns instead of inventing new data paths.
  • Keep each command focused: one clear job, typed input, typed output.
  • Introduce feature flags/options only after proving a real need.
  • Keep frontend changes small: trigger command, handle loading/error, display bounded data.

Anti-patterns to avoid

  • Doing large data transforms in React useMemo or useEffect.
  • Returning huge raw row sets to the UI and shaping them in JavaScript.
  • Recomputing heavy derived data on every render or keystroke.
  • Mixing unrelated concerns into a single Rust command handler.

Review checklist

  • Is the heavy work in Rust instead of JavaScript?
  • Are reads and payloads explicitly bounded?
  • Is memory growth controlled for worst-case input size?
  • Is command/repository wiring following existing VeloxDB patterns?
  • Does the UI virtualize large lists/tables and avoid unnecessary recomputation?

© veloxbase, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .cursor/skills/rust-heavy-performance of veloxbase/veloxdb.

Open the folder on GitHubat commit 2ca04f2

Compare with similar skills

Rust Heavy Performance next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Rust Heavy Performance compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Rust Heavy Performance this skillveloxbase/veloxdb646—~733Automated safety check: PassMIT
Cdphuoshen80/ReinaManager693—~178Automated safety check: PassAGPL-3.0
Database Opsbkywksj/knowledge-base330—~1.9kAutomated safety check: PassCustom licence
Brainstormbkywksj/knowledge-base330—~1.4kAutomated safety check: PassCustom licence
Memorywhalewuisabel-gif/MemWhale151—~765Automated safety check: PassMIT
Frontend Testhuoshen80/ReinaManager693—~180Automated safety check: PassAGPL-3.0

Similar skills

  • Cdp

    huoshen80/ReinaManager

    通过 CDP 连接 ReinaManager WebView2，复现、诊断并验证真实应用的前端问题。仅在用户显式调用 /cdp 或 $cdp 进行前端调试时使用。

    693 GitHub stars~178 tokensUpdated 4 days ago
    DatabasesAuto-check passed

  • Database Ops

    bkywksj/knowledge-base

    Tauri 本地数据库操作技能，使用 rusqlite 进行 SQLite 数据库操作. An agent skill from bkywksj/knowledge-base.

    330 GitHub stars~1.9k tokensUpdated 5 days ago
    DatabasesAuto-check passed

  • Brainstorm

    bkywksj/knowledge-base

    当需要探索方案、头脑风暴、创意思维时自动使用此 Skill. An agent skill from bkywksj/knowledge-base.

    330 GitHub stars~1.4k tokensUpdated 5 days ago
    Agent WorkflowsAuto-check passed

  • Memorywhale

    wuisabel-gif/MemWhale

    Query and write durable debugging memory recorded by MemoryWhale.

    151 GitHub stars~765 tokensUpdated 2 days ago
    Agent WorkflowsAuto-check passed

  • Frontend Test

    huoshen80/ReinaManager

    在 ReinaManager 项目内进行隔离前端验证，复用测试目录并回收测试资源。需要模拟批量数据、延迟、失败或交互回归时使用。

    693 GitHub stars~180 tokensUpdated 4 days ago
    Frontend & DesignAuto-check passed

  • Memorywhale Evidence

    wuisabel-gif/MemWhale

    Use MemoryWhale debugging evidence when the user requests recall or a recurring failure may have relevant recorded history.

    151 GitHub stars~459 tokensUpdated 2 days ago
    Agent WorkflowsAuto-check passed

More from veloxbase/veloxdb

  • Reactflow Workflow

    veloxbase/veloxdb

    Build and harden React Flow diagram surfaces in VeloxDB using @xyflow/react patterns (nodes, edges, viewport, controls, interactions, performance).

    646 GitHub stars~897 tokensUpdated 7 days ago
    Auto-check passed

  • Veloxdb Scalable Performance

    veloxbase/veloxdb

    Guides scalability and performance work for VeloxDB's Tauri + Rust PostgreSQL backend and React + TanStack frontend.

    646 GitHub stars~1.7k tokensUpdated 7 days ago
    Auto-check passed

Works with

Categories

Questions about Rust Heavy Performance

What does Rust Heavy Performance do?

Enforces a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of JavaScript. Rust Heavy Performance is an agent skill from veloxbase/veloxdb. Enforces a Rust-first approach for heavy work in VeloxDB so expensive compute stays in Tauri/Rust instead of JavaScript.

When should I use Rust Heavy Performance?

Rust Heavy Performance fits situations like: changing heavy queries; transformations; any path where performance is critical.

How do I install Rust Heavy Performance in Claude Code?

Run `npx skills add veloxbase/veloxdb --skill rust-heavy-performance -a claude-code`. Or copy the skill folder (.cursor/skills/rust-heavy-performance in veloxbase/veloxdb) into .claude/skills/rust-heavy-performance in your project. Claude Code loads it when a task matches its description.

How do I install Rust Heavy Performance in Codex?

Run `npx skills add veloxbase/veloxdb --skill rust-heavy-performance -a codex`. Or copy the skill folder (.cursor/skills/rust-heavy-performance in veloxbase/veloxdb) into .agents/skills/rust-heavy-performance in your project. Codex loads it when a task matches its description.

Can I use Rust Heavy Performance in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add veloxbase/veloxdb --skill rust-heavy-performance -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/rust-heavy-performance, .gemini/skills/rust-heavy-performance, .github/skills/rust-heavy-performance and .opencode/skills/rust-heavy-performance in your project.

What does Rust Heavy Performance need to run?

SKILL.md names no scripts, command-line tools or credentials: Rust Heavy Performance is instructions for the agent only.

Does Rust Heavy Performance access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Rust Heavy Performance safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Rust Heavy Performance use?

Rust Heavy Performance is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Rust Heavy Performance use?

About 733 tokens (SKILL.md is roughly 2.9k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Rust Heavy Performance?

Skills that share tags, products or a category with Rust Heavy Performance: Cdp (huoshen80/ReinaManager, 693 stars), Database Ops (bkywksj/knowledge-base, 330 stars), Brainstorm (bkywksj/knowledge-base, 330 stars) and Memorywhale (wuisabel-gif/MemWhale, 151 stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Rust Heavy Performance?

veloxbase (a GitHub organization) maintains it in veloxbase/veloxdb, which has 646 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on September 30, 2026.

Source: veloxbase/veloxdb on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.