Desktop IPC

You are a desktop application architect. The user wants to implement inter-process communication (IPC) between multiple processes in a desktop application.

What to check first

• Verify your target platform: Windows (named pipes), macOS/Linux (Unix domain sockets), or cross-platform (Electron IPC or socket libraries)
• Check if you're using Electron, native code, or a framework like Tauri — each has different IPC mechanisms
• Confirm whether you need bidirectional communication, message queuing, or simple request-response patterns

Steps

1. Choose your IPC transport layer — use ipcMain and ipcRenderer for Electron apps, or child_process with stdin/stdout for Node.js spawned processes
2. For Electron, define channel names as string constants to prevent typos across main and renderer processes
3. Set up the main process listener using ipcMain.handle() for async operations or ipcMain.on() for fire-and-forget messages
4. Implement message validation and sanitization on the main process side to prevent security vulnerabilities from renderer injection
5. In the renderer process, call ipcRenderer.invoke() for request-response or ipcRenderer.send() for one-way messages
6. Add error handling with try-catch blocks around invoke calls and error listeners on ipcMain handlers
7. For native C++ with Windows named pipes, use CreateNamedPipe() with proper security attributes and overlapped I/O for non-blocking communication
8. Implement a message serialization scheme (JSON, Protocol Buffers, or MessagePack) for complex data structures across process boundaries

Code

// main.js (Electron main process)
const { app, BrowserWindow, ipcMain } = require('electron');
const path = require('path');

let mainWindow;

// IPC channel constants
const IPC_CHANNELS = {
  GET_USER_DATA: 'get-user-data',
  SET_USER_DATA: 'set-user-data',
  FILE_OPERATION: 'file-operation',
  COMPUTE_TASK: 'compute-task'
};

app.on('ready', () => {
  mainWindow = new BrowserWindow({
    webPreferences: {
      preload: path.join(__dirname, 'preload.js'),
      nodeIntegration: false,
      contextIsolation: true
    }
  });
  mainWindow.loadFile('index.html');
});

// Async request-response pattern
ipcMain.handle(IPC_CHANNELS.GET_USER_DATA, async (event, userId) => {
  try {
    if (!Number.isInteger(userId)) {
      throw new Error('Invalid userId');
    }
    const userData = await fetchUserFromDatabase(userId);
    return { success: true, data: userData };
  } catch (error) {
    return { success: false, error: error.message };
  }
});

// One-way message with state

Note: this example was truncated in the source. See the GitHub repo for the latest full version.

Common Pitfalls

• Treating this skill as a one-shot solution — most workflows need iteration and verification
• Skipping the verification steps — you don't know it worked until you measure
• Applying this skill without understanding the underlying problem — read the related docs first

When NOT to Use This Skill

• When a simpler manual approach would take less than 10 minutes
• On critical production systems without testing in staging first
• When you don't have permission or authorization to make these changes

How to Verify It Worked

• Run the verification steps documented above
• Compare the output against your expected baseline
• Check logs for any warnings or errors — silent failures are the worst kind

Production Considerations

• Test in staging before deploying to production
• Have a rollback plan — every change should be reversible
• Monitor the affected systems for at least 24 hours after the change