Forking macOS Apps into KDE Plasma Widgets for Linux Devs

A few years ago, encountering a macOS-only development tool often meant abandoning it. Today, the mindset has shifted: if a tool solves a problem, why not adapt it? That’s exactly what happened when a developer on Linux stumbled upon Port Menu, a macOS menu bar app that lists local dev server ports.

The app’s core concept is straightforward—display active ports, identify their projects, and let users open or terminate them without terminal juggling. But with Linux as the primary OS, the tool’s macOS exclusivity posed a challenge. The solution? Forking it into a KDE Plasma widget named Portmanteau.

From SwiftUI to Plasma: Rethinking the Approach

Port Menu is built with SwiftUI and AppKit, which are deeply integrated into macOS. A direct port to Linux wasn’t feasible, but the underlying idea—a port scanner—was portable. Linux provides the necessary tools: ss, lsof, /proc//cwd, and commands like git and kill to manage processes.

However, replicating the SwiftUI interface wasn’t practical. Instead, the Linux version needed a KDE Plasma widget written in QML, complete with Plasma packaging, panel integration, and desktop-specific interactions. The project’s scope shifted from a port to a reimplementation of the same concept, tailored for Plasma 6.

The plan took shape as a small, JSON-emitting scanner paired with a Plasma widget. The scanner would handle port detection, while the widget would present the data in a user-friendly popup.

Planning with AI: From Chat to Workflow

With the concept clear, the next step was structuring the work. Using an AI agent and a project management tool called ticket, the developer outlined five epics:

• Linux Scanner Core
• KDE Plasma Widget MVP
• User Actions and Safety
• Packaging and Local Install
• Polish, Reliability, and Release Readiness

The AI agent generated 38 tickets with dependencies, creating a clear implementation order. This transformed the project from a casual chat into a structured workflow. The developer then tasked the agent with implementing the plan.

Building Portmanteau: A Linux-First Approach

The agent built the Linux version in a separate linux/ directory, leaving the original macOS app untouched. This separation ensured the macOS version remained intact while the Linux adaptation evolved independently.

The core components included:

• A Python-based scanner to detect local ports
• A JSON contract to standardize data exchange between the scanner and widget
• A Plasma widget to display ports and enable actions

The initial actions included opening a port’s URL, copying the port number, and killing the process. However, some features didn’t survive user testing. For example, copying the port number felt redundant alongside copying the URL, so the developer streamlined the actions to:

• Open
• Copy URL
• Kill

The agent implemented most of the tickets, but the developer conducted a review to catch edge cases. Issues like fragile packaging, scanner timeouts, and Plasma runtime quirks were identified and addressed.

Testing with Real Workloads

Before Portmanteau could be deemed usable, it needed real-world testing. The developer used an AI agent to spin up a Flask server for testing detection. The scanner successfully identified the server, outputting:

{
  "port": 5000,
  "processName": "python",
  "cwd": "/tmp/opencode",
  "projectName": "opencode",
  "url": "
}

Testing revealed minor UI quirks, such as duplicate-looking copy buttons and a kill action that didn’t work from the widget. These issues were quickly resolved, reinforcing the importance of human feedback in refining AI-generated code.

Naming and Branding: Portmanteau Takes Shape

With the core functionality in place, the developer focused on branding. The name Portmanteau—a play on "port" and the linguistic term for word blending—felt fitting for a tool that blends macOS and Linux workflows. A ship icon was chosen to evoke port-related imagery, adding a touch of personality.

The Lesson: Small Projects, Big Impact

This wasn’t a traditional software project. It started as a casual conversation with an AI agent and evolved into a functional tool in under a weekend. The workflow was iterative:

• Ask a question
• Plan the implementation
• Implement with AI assistance
• Review and refine
• Test with real use cases

For developers frustrated by macOS-only tools, forking and adapting them can unlock new productivity. The key isn’t just technical feasibility—it’s about tailoring the solution to your workflow. Portmanteau proves that even small projects can deliver outsized value when paired with the right tools and mindset.