rust heavy performance
- Repo stars 0
- Author repo skills-registry
- Domain
- Other
- Author-declared agents
- No explicit declaration found; this is not inferred or tested compatibility
- Static check
- 88 / 100 · heuristic scan, not runtime safety proof
- Runtime evidence
- Not run; no isolated runtime test evidence is currently recorded
- Author / version / license
- @tomevault-io · no license declared
- Token usage
- Lean
- Setup complexity
- Guided setup
- External API key
- Not required
- Operating systems
- Unspecified (assume cross-platform)
- Runtime requirements
- No explicit requirements detected
- Detected file/system behavior
-
- Read-only
- Shell exec
- Network behavior
- Local-only
- Install commands
- None (reference only)
Heads up: Tool permissions are not declared; actual access depends on the runtime.
# 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?
---
> Source: [abeni16/veloxdb](https://github.com/abeni16/veloxdb) — distributed by [TomeVault](https://tomevault.io).
<!-- tomevault:4.0:skill_md:2026-05-23 -->
Sections and files
Listed in source order.
sections -> Core rule → Rust-first implementation pattern → Memory efficiency guardrails → Speed guardrails → Easy-to-implement defaults → Anti-patterns to avoid
terms -> Use this skill when a feature can become slow or memory-heavy. · - If work is CPU-heavy, row-heavy, or repeatedly recomputed, do it in Rust. · 1. Add or extend an async command in src-tauri/src/commands.rs. · - Use bounded reads (LIMIT, pagination, or chunked iteration), never unbounded materialization. · - Push filtering, sorting, grouping, and aggregation down to SQL/Rust. · - Start from existing command and repository patterns instead of inventing new data paths. · - Doing large data transforms in React useMemo or useEffect. · - Is the heavy work in Rust instead of JavaScript?
files/cmd -> src-tauri/ · src-tauri/src/commands.rs · src-tauri/src/db.rs · src/data/repositories/ · invoke · LIMIT · useMemo · useEffect
body sha256 -> 1b0de4f9a619
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
Add or extend an async command in
src-tauri/src/commands.rs. Keep query execution and pooling logic insrc-tauri/src/db.rsand related Rust modules. Return a compact DTO to the frontend (already shaped for display). Call it fromsrc/data/repositories/using existinginvokepatterns. 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.