Electron or Tauri for a Clipboard Overlay?

Electron and Tauri are the two mainstream frameworks for building desktop utilities with web technologies. Electron bundles Chromium and Node.js; Tauri uses the OS's webview and a Rust backend. The choice matters for overlay utilities — clipboard shelves, screenshot tools, menubar apps — because the constraints are different from a normal app: small RAM footprint, native drag-and-drop, transparent windows, and click-through behavior. This comparison covers the trade-offs and explains why Edge-Drop is Electron today, and what would have to change for that to flip. For related reading, see why tray icons lost to edges and launchers, the case for boring clipboard software, what local-first software means for clipboard apps, and why some clipboard apps will never sync.

What each framework actually is

Electron

Electron is a framework from GitHub (now maintained by the OpenJS Foundation) that bundles Chromium and Node.js into a single runtime. The main process is Node.js; the renderer is Chromium; the two talk over IPC. An Electron app ships the entire runtime, which is why Electron installers are typically 80–150 MB and Electron apps use 100–200 MB of RAM at idle.

Electron's strengths are maturity, documentation, and ecosystem. The framework has been around since 2013, has a large plugin ecosystem, and handles edge cases like transparent windows, click-through, and OLE drag-and-drop well. VS Code, Slack, Discord, Figma Desktop, and 1Password are Electron apps.

Tauri

Tauri is a newer framework (1.0 in 2022) that uses the OS's native webview — WebView2 on Windows, WKWebView on macOS, WebKitGTK on Linux — and a Rust backend. The result is a much smaller binary (often 5–15 MB) and much lower RAM use (often 30–80 MB), because the webview is already on the system and the Rust binary is small.

Tauri's strengths are size, RAM, and security defaults. The framework is younger, the ecosystem is smaller, and some platform-specific features are harder than in Electron. EcoPaste and a growing list of utilities are Tauri apps.

The trade-off table

The pattern: Electron is heavier but more mature; Tauri is lighter but younger. For most utility categories, both work. For overlay utilities specifically, the trade-off tilts toward Electron for now, because the platform-specific features (OLE drag, transparent windows, click-through) are exactly where Electron's maturity pays off.

The overlay-utility specifics

Overlay utilities have a few requirements that normal desktop apps do not:

Transparent, always-on-top windows

The shelf has to be a transparent, always-on-top window that does not steal focus when opened. Electron handles this with transparent: true, alwaysOnTop: true, and focusable: false (or WS_EX_NOACTIVATE on Windows). The API is mature and the edge cases (composition disabled, fullscreen conflicts, multi-monitor DPI) are well-known.

Tauri supports transparent windows, but the support is younger. Some edge cases — particularly around Windows composition and multi-monitor DPI — have historically required more manual work than in Electron.

Click-through when collapsed

The shelf has to be click-through when collapsed, so the user can interact with the desktop behind it. Electron's setIgnoreMouseEvents(true, { forward: true }) is the API. It works, with known limitations around the forward flag on some Windows builds.

Tauri's equivalent exists but has been less battle-tested. For a clipboard shelf where click-through is a core interaction, the maturity gap matters.

Native drag-and-drop (OLE / startDrag)

The shelf has to support dragging an item out into a desktop app using real OS file handles, not HTML5 drag. Electron's webContents.startDrag(item) API does this: it takes an item with a file path and a custom drag image, and starts a native Win32 OLE drag. The receiving app sees a real file drop, not a webpage drag.

This is the hardest part to replicate in Tauri. Tauri's drag-and-drop surface is improving, but the equivalent of startDrag for files has historically required custom Rust code against the Windows API, which is more work than Electron's built-in. For a clipboard shelf where drag-out is the core interaction, this is the deciding factor.

Hover detection at a screen edge

The shelf has to detect when the cursor enters a thin hot zone at a screen edge. Both Electron and Tauri can do this with a transparent overlay window and pointer event handlers. The mechanism is the same; the maturity of the edge cases (multi-monitor, fullscreen suppression, hysteresis) differs.

Why Edge-Drop is Electron today

The honest summary of why Edge-Drop is Electron:

1. startDrag for files. Electron's webContents.startDrag is the API that makes drag-out into Photoshop, Word, and Explorer work cleanly. Replicating this in Tauri would require custom Rust code against the Windows API, which is more work and more risk.
2. Transparent, click-through windows. Electron's setIgnoreMouseEvents and the surrounding APIs are mature. Tauri's equivalents are younger.
3. Maturity for a solo project. Edge-Drop is solo-maintained. Electron's larger ecosystem means more Stack Overflow answers, more plugins, more prior art. For a solo developer, this matters.
4. Stack alignment. Edge-Drop uses React 18, TypeScript, Zustand, and Framer Motion. Electron's renderer is Chromium, which runs these without compatibility surprises. Tauri's WebView2 is also Chromium on Windows, but the cross-platform webview variance is a consideration for a project that may one day ship beyond Windows.

The cost of this choice is RAM. Edge-Drop uses 130–160 MB at idle, which is heavier than a Tauri equivalent would be. For users on low-RAM hardware, this is a real objection, and the honest response is to point them to Ditto or Win+V, which are lighter. Edge-Drop does not compete on RAM and should not be sold as if it does. For more on that, see competing with Ditto without pretending to be Ditto and how much RAM a clipboard manager should use.

What would change the choice

A flip to Tauri would require:

1. A mature startDrag equivalent in Tauri. Either a first-party API or a well-maintained plugin that handles OLE drag on Windows, NSDragging on macOS, and DnD on Linux.
2. Mature transparent-window support. Particularly around multi-monitor DPI, fullscreen suppression, and Windows composition edge cases.
3. Mature click-through support. With the forward flag for hover detection.
4. A larger ecosystem. More plugins, more prior art, more answers on Stack Overflow. This is a network effect that grows with adoption.

None of these is impossible. Tauri is moving fast, and the gaps are closing. As of mid-2026, the gaps are still real for an overlay utility whose core interaction is drag-out. A Tauri rewrite of Edge-Drop is plausible in the future, but it is not on the immediate roadmap, and it is not a promise.

The hybrid possibility

A pattern worth noting: ship a Tauri shell for the lightweight chrome (tray icon, settings panel, hotkey listener) and embed an Electron-driven subwindow only for the shelf itself, where startDrag matters. This is more complex than a single-framework app, but it splits the cost — the always-running daemon is light, and the heavier renderer only spins up when the shelf is opened. The pattern is uncommon today but is likely to appear as Tauri's drag-out story matures. It is not the path Edge-Drop takes, but it is one to watch.

The honest case for each framework

Electron

Best for: overlay utilities with drag-out, transparent windows, and click-through; teams that value maturity over size; projects that need a large plugin ecosystem.

Cost: RAM. 100–200 MB at idle is normal, and there is no good way to make it much smaller.

Tauri

Best for: utilities where size and RAM matter more than drag-out; developers comfortable with Rust; projects that want the security defaults of a narrower IPC surface.

Cost: maturity. Some platform-specific features require more manual work, and the ecosystem is smaller.

For a clipboard shelf that needs drag-out, Electron is the practical choice today. For a clipboard manager that is list-only and does not need drag-out, Tauri is a strong choice, and EcoPaste is evidence that the pattern works.

For more on the broader design questions, see the case for boring clipboard software and why tray icons lost to edges and launchers.

Related reading

• The Case for Boring Clipboard Software
• What Edge-Drop Is Not Trying to Become
• What Local-First Software Means for Clipboard Apps
• How to Enable Clipboard History in Windows 11

Sources

• Electron — Documentation — official Electron documentation, including the BrowserWindow, webContents, and IPC APIs
• Electron — webContents.startDrag — official API reference for the native drag-out API that makes Edge-Drop's drag-into-Photoshop interaction work
• Tauri — Documentation — official Tauri documentation, including the Rust backend, webview frontend, and IPC model
• Tauri — Window configuration — official documentation for Tauri's transparent and always-on-top window support
• Microsoft Learn — WebView2 — official documentation for the Windows webview that Tauri uses on Windows

Copy. Stack. Drop.

Transform your clipboard into an interactive edge shelf. Stack, pin, and drag assets into any app with zero friction.

Download for Windows Get from Microsoft Store

How to Install Guide · First 10 Minutes Guide · Drag & Drop Guide · Edge-Drop vs Win+V · Support