Migrating from Electron

Decide on runtime: lite or full

• lite — if your main process only uses fs, path, http, basic stdlib. Smallest binary.
• full — if you have npm deps with native bindings (sharp, better-sqlite3, canvas, bcrypt), or use specific Bun/Node APIs.

Start with lite unless you know you need full.

Init Tynd

In your existing project:

bunx @tynd/cli init

This detects your frontend build tool, writes tynd.config.ts, scaffolds backend/main.ts.

Port the main process

Electron main processes typically look like this:

// OLD — main.ts (Electron)
import { app, BrowserWindow, ipcMain } from "electron";
import { readFile } from "node:fs/promises";
 
ipcMain.handle("read-config", async () => {
  const body = await readFile("./config.json", "utf8");
  return JSON.parse(body);
});
 
app.whenReady().then(() => {
  const win = new BrowserWindow({
    width: 1200,
    height: 800,
    webPreferences: {
      contextIsolation: true,
      preload: "preload.js",
    },
  });
  win.loadFile("dist/index.html");
});

Tynd equivalent:

import { app } from "@tynd/core";
import { fs } from "@tynd/core/client";
 
export async function readConfig() {
  return JSON.parse(await fs.readText("./config.json"));
}
 
app.start({
  window: { width: 1200, height: 800 },
});

Gone:

• BrowserWindow — app.start creates the window.
• contextIsolation / preload — Tynd injects IPC shims only. No Node globals leak into the renderer.
• ipcMain.handle — every export is an RPC method.

Port the renderer

// OLD — renderer.ts (Electron + contextBridge)
const config = await window.api.readConfig();
 
// preload.ts had:
// contextBridge.exposeInMainWorld("api", {
//   readConfig: () => ipcRenderer.invoke("read-config"),
// });

// NEW — src/main.ts (Tynd)
import { createBackend } from "@tynd/core/client";
import type * as backend from "../backend/main";
 
const api = createBackend<typeof backend>();
const config = await api.readConfig();

Zero preload, zero glue, types flow from typeof backend.

Port events

// OLD — Electron
// main.ts
win.webContents.send("progress", 0.42);
 
// renderer.ts
window.api.onProgress((pct) => render(pct));

// NEW — Tynd
// backend/main.ts
import { createEmitter } from "@tynd/core";
export const events = createEmitter<{ progress: number }>();
events.emit("progress", 0.42);
 
// frontend
api.on("progress", (pct) => render(pct));

Port Node APIs

In full mode, most Node APIs work unchanged. In lite, replace with Tynd OS APIs:

What has no Tynd replacement

• desktopCapturer (screen capture). No alternative. Use a native CLI via sidecar (e.g. ffmpeg).
• printToPDF (webview to PDF). Use a pure-JS lib like jspdf, or render server-side via sidecar.
• findInPage. Implement in JS with a content-search overlay on your app HTML.
• Built-in spellcheck. Use nspell + Hunspell dictionaries, or the browser’s native spellcheck attribute.
• Chrome extensions. Not supported by the WebView stack.
• Touch Bar (macOS). Not exposed.
• StoreKit IAP. Not exposed.

Port the build

Replace your Electron build tooling (electron-builder, electron-forge) with tynd build --bundle:

tynd build --bundle        # .app, .dmg, .deb, .rpm, .AppImage, NSIS, MSI for host OS

See Bundling.

Port CI

Remove Electron-specific steps (Electron download cache, ASAR packaging). Use the matrix pattern from the Bundling guide — tynd build --bundle per OS.

Port code signing

If you were signing Electron builds, your certs work as-is — signtool and codesign are the same tools. Just declare bundle.sign in tynd.config.ts and tynd build handles signing + (optional) notarization. See Code Signing.

Port the updater

Tynd’s updater uses the Tauri-compatible manifest format. If you were already using electron-updater, you’ll need a new manifest (different shape). But if you were using a custom update flow on top of autoUpdater, the primitives are similar:

• Fetch manifest JSON.
• Compare versions.
• Download + verify signature.
• Swap + relaunch.

See Auto-Updates.