Wendy Swift logo

Wendy Swift

Organization
wendylabsinc
wendy-swift

Curated Swift package ecosystem for WendyOS and Linux. Use when developers mention: (1) Swift packages for Linux or ARM64/AMD64, (2) choosing a Swift library, (3) Swift Package Index, (4) swiftpackageindex.com, (5) what Swift library to use, (6) Swift on WendyOS dependencies, (7) edge computing Swift libraries.

Overview

Publisherwendylabsinc
Repositoryclaude-skills
Skill namewendy-swift
Stars
62
Forks
5
Bundled files
Instructions only
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • Self-contained

    Everything the model needs lives in the instructions — no extra files to sync.

  • Open source

    Published by wendylabsinc on GitHub. Read the source before you install it.

Installation

Install the Wendy Swift AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/wendylabsinc/claude-skills/tree/main/wendy-swift
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/wendylabsinc/claude-skills.git /tmp/claude-skills
mkdir -p .claude/skills
cp -r /tmp/claude-skills/wendy-swift .claude/skills/wendy-swift
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Wendy Swift in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Wendy Swift on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Wendy Swift is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Swift Package Ecosystem for WendyOS

This skill maps the Swift package ecosystem for WendyOS (Linux) edge development. It provides curated recommendations organized by domain and guidance for discovering additional packages via Swift Package Index.

Curated Package Catalog

Web / HTTP Servers

PackageUse CaseURLLinux
Hummingbird 2Lightweight HTTP server, routing, middlewarehttps://github.com/hummingbird-project/hummingbirdFull support
VaporFull-featured web framework with ORM, auth, sessionshttps://github.com/vapor/vaporFull support

Networking / SwiftNIO

PackageUse CaseURLLinux
SwiftNIOEvent-driven networking framework, TCP/UDPhttps://github.com/apple/swift-nioFull support
AsyncHTTPClientHTTP/1.1 and HTTP/2 clienthttps://github.com/swift-server/async-http-clientFull support
gRPC Swift 2gRPC client and server built on SwiftNIO and Swift Concurrencyhttps://github.com/grpc/grpc-swift-2Full support
Swift OpenAPI GeneratorGenerate client/server code from OpenAPI specshttps://github.com/apple/swift-openapi-generatorFull support

Databases

PackageUse CaseURLLinux
PostgresNIONon-blocking PostgreSQL client built on SwiftNIOhttps://github.com/vapor/postgres-nioFull support
GRDB.swiftSQLite toolkit with query builder, migrations, WALhttps://github.com/groue/GRDB.swiftFull support
Valkey SwiftValkey/Redis client with cluster support, pub/subhttps://github.com/valkey-io/valkey-swiftFull support

ML / AI Inference

PackageUse CaseURLLinux
llama.cppLLM inference with Swift bindingshttps://github.com/ggerganov/llama.cppFull support (C library with Swift bindings)
whisper.cppSpeech-to-text inferencehttps://github.com/ggerganov/whisper.cppFull support (C library with Swift bindings)
MLX SwiftML framework for Apple Siliconhttps://github.com/ml-explore/mlx-swiftmacOS/Apple Silicon only — not available on Linux

For llama.cpp and whisper.cpp, use the C API directly via Swift's C interop or use community Swift wrapper packages. These libraries compile natively on ARM64/AMD64 Linux.

Hardware / IoT

PackageUse CaseURLLinux
SwiftyGPIOGPIO, SPI, I2C, PWM, UART on Linux SBCshttps://github.com/uraimo/SwiftyGPIOFull support (Linux only)

Camera/video access patterns: Use Video4Linux2 (V4L2) through Swift's C interop for camera capture on Linux. For NVIDIA Jetson, use GStreamer pipelines via Process or C bindings for hardware-accelerated video.

Serial communication: Use termios via Swift's C interop for serial port access on Linux. SwiftyGPIO also provides UART support for common SBCs.

Observability

PackageUse CaseURLLinux
swift-logStructured logging APIhttps://github.com/apple/swift-logFull support
swift-metricsMetrics API (counters, gauges, timers)https://github.com/apple/swift-metricsFull support
swift-otelOpenTelemetry backend for swift-log, swift-metrics, and distributed tracinghttps://github.com/swift-otel/swift-otelFull support
swift-distributed-tracingDistributed tracing APIhttps://github.com/apple/swift-distributed-tracingFull support

Serialization / Codable

PackageUse CaseURLLinux
swift-protobufProtocol Buffers with Codable supporthttps://github.com/apple/swift-protobufFull support
msgpack-swiftMessagePack encoder/decoder, Codable-complianthttps://github.com/fumoboy007/msgpack-swiftFull support
YamsYAML parser and emitterhttps://github.com/jpsim/YamsFull support

Concurrency / Utilities

PackageUse CaseURLLinux
swift-collectionsDeque, OrderedSet, OrderedDictionary, and morehttps://github.com/apple/swift-collectionsFull support
swift-algorithmsSequence/collection algorithms (chunked, combinations, etc.)https://github.com/apple/swift-algorithmsFull support
swift-async-algorithmsAsync sequence algorithms (merge, combineLatest, debounce, etc.)https://github.com/apple/swift-async-algorithmsFull support
swift-argument-parserType-safe command-line argument parsinghttps://github.com/apple/swift-argument-parserFull support

Linux Compatibility Checklist

Before adding a Swift package to a WendyOS project, verify:

  1. No Darwin-only imports — Check for import Darwin, import AppKit, import UIKit, import CoreFoundation (some Foundation APIs are fine on Linux, but not all)
  2. Foundation compatibility — Avoid APIs that are unimplemented on Linux: FileManager works, but NSAppleScript, NSUserDefaults, Process (partially available), etc. may not
  3. No Xcode build system dependencies — The package must build with swift build (SPM), not require Xcode-specific settings
  4. ARM64/AMD64 CI/testing — Check if the package has Linux CI (GitHub Actions with ubuntu runners or Swift Docker images)
  5. C dependencies — If the package wraps a C library, ensure that library is available on ARM64/AMD64 Linux (e.g., via apt)
  6. Swift version — WendyOS uses recent Swift toolchains; confirm the package supports Swift 5.9+

Finding Packages on Swift Package Index

Swift Package Index is the community package search engine.

How to search

  1. Go to https://swiftpackageindex.com and enter your search term
  2. Use the Platform filter to select Linux to find Linux-compatible packages
  3. Check the Compatibility Matrix on each package page — it shows which Swift versions and platforms are tested

Evaluating package quality

  • Last activity — Prefer packages updated within the last 6 months
  • Swift version compatibility — Should support Swift 5.9 or later
  • Platform badges — Look for the Linux badge on the package page
  • License — Prefer Apache 2.0 or MIT for commercial use
  • SSWG status — Packages incubated by the Swift Server Work Group are production-vetted

Search URL pattern

Direct search: https://swiftpackageindex.com/search?query=YOUR_TERM

Best Practices

  1. Use the curated list first — Packages listed above are vetted for Linux and WendyOS compatibility
  2. Prefer SSWG packages — Swift Server Work Group packages (SwiftNIO, swift-log, async-http-client, Hummingbird, PostgresNIO) have strong Linux support guarantees
  3. Watch for architecture-specific code — Swift packages compile from source, so ARM64/AMD64 works automatically unless the package contains x86-specific assembly, SIMD intrinsics, or architecture-gated #if blocks
  4. Avoid Darwin-only dependencies — Even transitive dependencies can break Linux builds; use swift package show-dependencies to audit the tree
  5. Pin to stable versions — Use .upToNextMajor(from:) or .upToNextMinor(from:) in Package.swift rather than branch-based dependencies
  6. Fall back to Swift Package Index — If the curated list doesn't cover your need, search swiftpackageindex.com with the Linux platform filter
  7. Test on Linux early — Build and run on a WendyOS device or Linux VM early to catch missing Foundation APIs and Darwin-only dependencies before they compound

Frequently asked questions

What does the Wendy Swift AI skill do?

Curated Swift package ecosystem for WendyOS and Linux. Use when developers mention: (1) Swift packages for Linux or ARM64/AMD64, (2) choosing a Swift library, (3) Swift Package Index, (4) swiftpackageindex.com, (5) what Swift library to use, (6) Swift on WendyOS dependencies, (7) edge computing Swift libraries.

Why use Wendy Swift on TypingMind?

Because you install it once and use it with any model. Wendy Swift is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Wendy Swift in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/wendylabsinc/claude-skills/tree/main/wendy-swift. TypingMind reads its SKILL.md and installs it as a skill you can enable per chat.

Which AI models can use Wendy Swift?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Wendy Swift?

As many as you like. As long as a model supports skills, you can use Wendy Swift with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Wendy Swift AI skill free?

It is published on GitHub by wendylabsinc. Check the repository for licensing terms. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇