New: 98,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

Native Feel Cross Platform Desktop

by yetone in yetone/native-feel-skill

A skill your agent uses when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a…

MITAuto-check passedDevelopment

Install Native Feel Cross Platform Desktop

skills CLI
$ npx skills add yetone/native-feel-skill --skill native-feel-cross-platform-desktop -a claude-code

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

GitHub CLI
$ gh skill install yetone/native-feel-skill native-feel-cross-platform-desktop --agent claude-code

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

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

Facts

Skill name
native-feel-cross-platform-desktop
GitHub stars
1.9k
Used in
1 other repo
Token cost
~1.5k tokens
SKILL.md length
750 words
Files
13 (incl. references)
Skills in repo
1
Repo updated
First seen
Licence
MIT

At a glance

A skill your agent uses when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a…

  • Works in 4 steps: Start with the philosophy in… → Match the user's question to a reference… → Before recommending an architecture, run… → …
  • The user is designing
  • SKILL.md covers How to use this skill, The one-paragraph version, Core anti-patterns to call out… and Output style
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Native Feel Cross Platform Desktop is an agent skill from yetone/native-feel-skill. Use when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a native app to its users — fast launch, native windowing, native input handling, native materials. Trigger words include "cross-platform desktop", "Electron alternative", "Tauri vs native", "WebView wrapper", "near-native performance", "Raycast architecture", "WebKit/WebView2 quirks", "WKWebView", "system tray app", "global hotkey app"…

Its SKILL.md is about 1.5k tokens, which your agent loads only when the skill is triggered. The skill folder holds 14 other files, including reference files (for example `README.md`, `checklists/decision-tree.md` and `checklists/ship-readiness.md`).

It sits in Development, covering Prototyping. It works with macOS, Tauri and Linux. The repository describes itself as: An Agent Skill for designing cross-platform desktop apps that feel native — distilled from Raycast's 2.0 deep-dive and reverse engineering of Raycast Beta.app. Eight… The licence is MIT.

When your agent uses it

  • The user is designing
  • Rewriting a desktop app that must run on multiple OSes (macOS + Windows
  • Optionally Linux) AND feel indistinguishable from a native app to its users — fast launch
  • Native windowing

Example prompts

  • “cross-platform desktop”
  • “Electron alternative”
  • “Tauri vs native”
  • “/native-feel-cross-platform-desktop”

Workflow steps

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

  1. Start with the philosophy in references/01-philosophy.md. It frames the central tension this architecture resolves — how to get…
  2. Match the user's question to a reference file. Don't dump the whole skill — load only what's needed
  3. Before recommending an architecture, run the decision tree in checklists/decision-tree.md. It rules this stack OUT for several common…
  4. Before the user claims their app "feels native", run checklists/ship-readiness.md. It's a 30-item audit; most apps fail 5–10 items on…

What it can do on your machine

Read from SKILL.md and the folder at commit 9bd88c6. 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

Native Feel Cross Platform Desktop loads about 1.5k tokens when it runs, and up to ~21k if it reads all its reference files. Until then it costs about 172 tokens; SKILL.md has 750 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~172
When it runs · the whole SKILL.md, loaded when a task matches
~1.5k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~21k

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 yetone/native-feel-skill at commit 9bd88c6, republished under its MIT licence (© yetone). 750 words, ~1,527 tokens.

Download SKILL.mdSave it as .claude/skills/native-feel-cross-platform-desktop/SKILL.md (or your agent's skills folder). This skill also uses 12 other files; get the full folder from GitHub.
name
native-feel-cross-platform-desktop
description
Use when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a native app to its users — fast launch, native windowing, native input handling, native materials. Trigger words include "cross-platform desktop", "Electron alternative", "Tauri vs native", "WebView wrapper", "near-native performance", "Raycast architecture", "WebKit/WebView2 quirks", "WKWebView", "system tray app", "global hotkey app", "launcher app". Do NOT trigger this skill for pure web apps, pure mobile apps, or for greenfield projects that have no native-feel requirement.

Native-Feel Cross-Platform Desktop

You are advising on the architecture of a cross-platform desktop app that must feel native. This skill captures the philosophy, architecture, and concrete pitfalls — distilled from Raycast's public technical deep-dive on their 2.0 rewrite and verified by reverse-engineering the shipping Raycast Beta.app binary on macOS.

How to use this skill

  1. Start with the philosophy in references/01-philosophy.md. It frames the central tension this architecture resolves — how to get cross-platform DX and near-native performance at the same time — and gives you eight tenets that name the structural moves. Every concrete decision later flows from one of those tenets. If the user is making a decision that contradicts a tenet, surface the tenet by number and short name and explain the trade-off.
  2. Match the user's question to a reference file. Don't dump the whole skill — load only what's needed:
    • Architecture / "which layers should I have?" → references/02-architecture.md
    • "Why does my WebView flicker / stutter / freeze when hidden?" → references/03-webview-survival.md (the highest-density file — every item is a real bug with a real fix)
    • "How do I type my IPC across Rust/Swift/C#/TS?" → references/04-ipc-contract.md
    • "Why does Activity Monitor say 400 MB?" → references/05-memory-truths.md
    • "How do I make it not feel like a webpage?" → references/06-native-conventions.md
    • "What does Raycast actually ship?" (concrete evidence) → references/07-evidence-raycast.md
  3. Before recommending an architecture, run the decision tree in checklists/decision-tree.md. It rules this stack OUT for several common project shapes — say so directly.
  4. Before the user claims their app "feels native", run checklists/ship-readiness.md. It's a 30-item audit; most apps fail 5–10 items on first pass.

The one-paragraph version

A native-feel cross-platform desktop app is not a web app with native hooks and not Electron with a custom theme. It is a native shell (Swift/AppKit on macOS, C#/WPF on Windows) that owns the window, the hotkeys, the menu bar, the materials, and the lifecycle — and embeds the system WebView (WKWebView or WebView2) purely as a rendering surface for a shared React/TypeScript UI. Business logic lives in a long-lived Node process bundled with the app. Performance-critical subsystems (file indexing, calculation, crypto) live in Rust, shared across platforms and exposed through UniFFI-generated typed bindings. Four runtimes communicate through a single declared interface that generates typed clients for each side. The whole thing fits in ~400 MB resident memory, of which ~150 MB is the inescapable WebView+Node baseline. You pay that baseline so that one React codebase serves both OSes; you earn it back through hot-reload iteration speed and a shared extension API that already runs thousands of community plugins on both platforms.

Show full SKILL.md (332 more words)Show less

Core anti-patterns to call out immediately

When you see the user doing any of these, stop and ask:

  • "Let's just use Electron and theme it" → Electron abstracts away the system WebView, window class, and material APIs you need for native feel. You cannot get Liquid Glass / acrylic / true vibrancy through Electron's abstraction without forking it. Recommend references/02-architecture.md instead.
  • "Let's use Tauri — it's like Electron but lighter" → Tauri ships its own WebView wrapper and abstracts platform APIs. Same control-loss problem as Electron, plus less mature. Acceptable for utilities; not for apps where every window animation has to match the OS.
  • "Let's render UI in Swift/C# and share business logic" → You will maintain two UI codebases forever. Every feature ships twice. Designers maintain two specs. Recommend WebView-as-renderer instead.
  • "WebKit is throttling us; let's spin our own polling loop" → No. The throttling is solvable with two specific WKWebView configuration flags. See references/03-webview-survival.md § "Hidden window throttling".
  • "Memory is bad — we're at 400 MB" → Probably wrong measurement. Activity Monitor double-counts shared frameworks and treats compressed pages as resident. See references/05-memory-truths.md before optimizing anything.
  • "Let's hand-write the IPC types in each language" → They will drift within a sprint. Use UniFFI (for Rust ↔ Swift/Kotlin/C#) or hand-roll a single IDL that generates clients. See references/04-ipc-contract.md.
  • "Adding cursor: pointer to make it feel responsive" → That's exactly what makes it feel web. Native UIs do not change the cursor on hoverable rows. See references/06-native-conventions.md.

Output style

When advising:

  • Quote the specific tenet from references/01-philosophy.md that applies (e.g., "T3 — adopt the platform; don't compete with it: the OS draws blur better than you can").
  • Cite the file and section, not the whole skill.
  • For each recommendation, name what the user is giving up in exchange. There are no free wins in this architecture — the whole skill is about deliberate trade-offs.
  • If you're unsure whether the user's project should even use this architecture, run them through checklists/decision-tree.md before giving advice. It is okay to conclude "this skill doesn't apply — build a normal Electron app."

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

Files

SKILL.md and 12 other files (references) in the repository root of yetone/native-feel-skill.

  • SKILL.md
  • .gitignore
  • LICENSE
  • README.md
  • checklists/decision-tree.md
  • checklists/ship-readiness.md
  • references/01-philosophy.md
  • references/02-architecture.md
  • references/03-webview-survival.md
  • references/04-ipc-contract.md
  • references/05-memory-truths.md
  • references/06-native-conventions.md
  • references/07-evidence-raycast.md

Open the folder on GitHubat commit 9bd88c6

Used in 1 other repository

We found 1 copy of this SKILL.md (exact, near-identical or edited) in other folders, from 1 other GitHub owner. This page covers the copy in yetone/native-feel-skill, which our catalogue first saw on October 7, 2026.

Compare with similar skills

Native Feel Cross Platform Desktop 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.

Native Feel Cross Platform Desktop compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Native Feel Cross Platform Desktop this skillyetone/native-feel-skill1.9k1 repos~1.5kAutomated safety check: PassMIT
DeepChat Data Import HelperThinkInAIXYZ/deepchat6.4k—~738Automated safety check: PassApache-2.0
Tauri Packagingbkywksj/knowledge-base330—~3.3kAutomated safety check: PassCustom licence
JS Cpp Protocolnotepadqq/notepadqq2.3k—~3.2kAutomated safety check: PassGPL-3.0
RStudio Copilot Language Server Updaterrstudio/rstudio5.1k—~1.1kAutomated safety check: PassCustom licence
OpenLogi Device DiagnosisAprilNEA/OpenLogi23k—~1.6kAutomated safety check: PassApache-2.0

Similar skills

  • DeepChat Data Import Helper

    ThinkInAIXYZ/deepchat

    Guides building a third-party importer for DeepChat's local SQLite data, covering schema, encryption and safe read-only access patterns.

    6.4k GitHub stars~738 tokensUpdated today
    DatabasesAuto-check passed

  • Tauri Packaging

    bkywksj/knowledge-base

    Tauri 打包与分发技能,指导桌面端（Windows/macOS/Linux）与移动端（Android/iOS）的构建、签名和分发。

    330 GitHub stars~3.3k tokensUpdated today
    MobileAuto-check passed

  • JS Cpp Protocol

    notepadqq/notepadqq

    Reference for the communication protocol between the JavaScript editor (CodeMirror or Monaco) and the C++/Qt UI layer via QWebChannel.

    2.3k GitHub stars~3.2k tokensUpdated 4 days ago
    DevelopmentAuto-check passed

  • RStudio Copilot Language Server Updater

    rstudio/rstudio

    Advances RStudio's pinned copilot-language-server dependency to a specified release, then uploads it to S3, verifies the install, and opens a PR.

    5.1k GitHub stars~1.1k tokensUpdated today
    DevelopmentAuto-check passed

  • OpenLogi Device Diagnosis

    AprilNEA/OpenLogi

    Finds the first failing layer when an OpenLogi Logitech device is missing or misbehaving across enumeration, open, probe, IPC and UI.

    23k GitHub stars~1.6k tokensUpdated today
    DevelopmentAuto-check passed

  • Code Change Verification

    openai/openai-agents-python

    Official

    Run the required final formatting, lint, type, and test checks after eligible SDK changes pass review.

    30k GitHub stars~1.4k tokensUpdated yesterday
    DevelopmentAuto-check passed

Works with

Categories

Questions about Native Feel Cross Platform Desktop

What does Native Feel Cross Platform Desktop do?

A skill your agent uses when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a…. Native Feel Cross Platform Desktop is an agent skill from yetone/native-feel-skill. Use when the user is designing, prototyping, or rewriting a desktop app that must run on multiple OSes (macOS + Windows, optionally Linux) AND feel indistinguishable from a native app to its users — fast launch, native windowing, native input handling, native materials.

When should I use Native Feel Cross Platform Desktop?

Native Feel Cross Platform Desktop fits situations like: the user is designing; rewriting a desktop app that must run on multiple OSes (macOS + Windows; optionally Linux) AND feel indistinguishable from a native app to its users — fast launch; native windowing.

How do I install Native Feel Cross Platform Desktop in Claude Code?

Run `npx skills add yetone/native-feel-skill --skill native-feel-cross-platform-desktop -a claude-code`. Or copy the skill folder (the yetone/native-feel-skill repository) into .claude/skills/native-feel-cross-platform-desktop in your project. Claude Code loads it when a task matches its description.

How do I install Native Feel Cross Platform Desktop in Codex?

Run `npx skills add yetone/native-feel-skill --skill native-feel-cross-platform-desktop -a codex`. Or copy the skill folder (the yetone/native-feel-skill repository) into .agents/skills/native-feel-cross-platform-desktop in your project. Codex loads it when a task matches its description.

Can I use Native Feel Cross Platform Desktop 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 yetone/native-feel-skill --skill native-feel-cross-platform-desktop -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/native-feel-cross-platform-desktop, .gemini/skills/native-feel-cross-platform-desktop, .github/skills/native-feel-cross-platform-desktop and .opencode/skills/native-feel-cross-platform-desktop in your project.

What does Native Feel Cross Platform Desktop need to run?

SKILL.md names no scripts, command-line tools or credentials: Native Feel Cross Platform Desktop is instructions for the agent only.

Does Native Feel Cross Platform Desktop 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 Native Feel Cross Platform Desktop 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 Native Feel Cross Platform Desktop use?

Native Feel Cross Platform Desktop is published under the MIT licence (from the LICENSE file in the skill folder). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Native Feel Cross Platform Desktop use?

About 1.5k tokens (SKILL.md is roughly 6.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 20k tokens, read only when the agent opens those files.

What are the alternatives to Native Feel Cross Platform Desktop?

Skills that share tags, products or a category with Native Feel Cross Platform Desktop: DeepChat Data Import Helper (ThinkInAIXYZ/deepchat, 6.4k stars), Tauri Packaging (bkywksj/knowledge-base, 330 stars), JS Cpp Protocol (notepadqq/notepadqq, 2.3k stars) and RStudio Copilot Language Server Updater (rstudio/rstudio, 5.1k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Native Feel Cross Platform Desktop?

yetone (a GitHub user) maintains it in yetone/native-feel-skill, which has 1,930 GitHub stars. The repository was last updated on May 30, 2026.

Source: yetone/native-feel-skill on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.