← Back to all articles

Here's how you save $800 with ElectronJS

November 1, 2025

Interview Coder 2.0 just launched, yes the viral cheating tool that was used to crack Amazon Interviews. You can use it to cheat through your Leetcode interviews as well, but at a cost.

$899 for lifetime access

I don't think that's feasible for a lot of students. Try convincing parents that you want to buy this cheating tool after they've paid for your college hoping you'd get a job.

Open Source is here to the rescue. You can check this out for free at https://github.com/Prat011/free-interview-coder and if you want the same interface fine tuned for different purposes: https://github.com/Prat011/free-cluely.

This is built with Electron and Typescript. ElectronJS is a framework that can be used to build desktop apps. Popular desktop apps like VS Code, Discord, Github and more are built with Electron.

The 3 most interesting parts of this project is

  1. Transparent overlay
  2. Staying undetected
  3. Realtime Transcription

The Transparent Overlay

The window that floats above everything else on your screen, but is completely transparent. Think of it as an invisible layer between you and your interview window.

Here's the Electron magic that makes it happen:

const windowSettings: Electron.BrowserWindowConstructorOptions = {
  frame: false,        // No title bar or borders
  transparent: true,   // See-through background
  alwaysOnTop: true,   // Floats above everything
  backgroundColor: "#00000000", // Fully transparent
  hasShadow: false,    // No visual shadow
  focusable: true      // Can still receive input
}

But alwaysOnTop: true isn't enough on macOS. Regular "always on top" windows still get buried under fullscreen apps. That's where the floating window level comes in:

this.mainWindow.setAlwaysOnTop(true, "floating")

Window levels on macOS go from normal → floating → modal-panel → screen-saver. The floating level ensures your overlay stays above:

  • Fullscreen browsers (where your Zoom interview runs)
  • Your IDE (where you're pretending to code)
  • Pretty much everything except the menu bar

2. Staying Undetected

A floating window is useless if it shows up in the screen share.

Content Protection

this.mainWindow.setContentProtection(true)

This single line prevents macOS screen recording and screenshot tools from capturing the window. When you share your screen on Zoom, the overlay simply doesn't exist in the stream. The interviewer sees your browser and your IDE, but not the AI answers floating on top.

Skip Taskbar

this.mainWindow.setSkipTaskbar(true)

This ensures the window doesn't appear in:

  • Your taskbar (Windows/Linux)
  • Your dock (macOS)
  • Alt+Tab window switcher
  • Any running applications list

From the OS perspective, this window is a ghost. It exists, it's rendering content, but it's not "officially" there.

The Dock Trick (macOS Only)

There's one more piece for stealth on macOS:

if (process.platform === 'darwin') {
  app.dock.hide()
}

This hides the entire application from the dock. Even if someone looks at your dock to see what's running, they won't see this app. Combined with the transparent window, you're essentially running an invisible application.

The limitation? This works great on macOS. On Windows and Linux, screen sharing tools are more aggressive, and some proctoring software can detect overlays. But for most Zoom/Meet/Teams interviews? You're completely invisible.

3. Realtime Transcription

An invisible overlay is useless if you have to manually type the interview questions. The real magic happens when you can transcribe the interviewer's audio in real-time and feed it directly to AI.

This project uses Gemini's Live API for real-time transcription. Here's how it works:

Step 1: Capture Audio from Two Sources

// Get microphone audio (to hear the interviewer)
const micStream = await navigator.mediaDevices.getUserMedia({
  audio: {
    echoCancellation: true,
    noiseSuppression: true,
    sampleRate: 16000
  }
})

// Get system audio (to capture Zoom/Meet audio output)
const systemStream = await navigator.mediaDevices.getDisplayMedia({
  video: false,
  audio: { sampleRate: 16000 }
})

// Mix both streams together
const audioContext = new AudioContext({ sampleRate: 16000 })
const destination = audioContext.createMediaStreamDestination()
micSource.connect(destination)
systemSource.connect(destination)

The key here is mixing microphone audio (your voice) with system audio (the interviewer's voice through Zoom). This ensures you capture both sides of the conversation.

Step 2: Connect to Gemini Live

const ai = new GoogleGenAI({ apiKey })
const session = await ai.live.connect({
  model: 'gemini-2.0-flash-exp',
  callbacks: {
    onmessage: (message) => {
      // Get transcription in real-time
      if (message.serverContent?.inputTranscription?.text) {
        const text = message.serverContent.inputTranscription.text
        setTranscript(prev => prev + text + " ")
      }
    }
  },
  config: {
    responseModalities: [Modality.TEXT],
    inputAudioTranscription: {}
  }
})

Gemini 2.0's Live API is designed for real-time voice conversations. It transcribes audio as it streams in, with extremely low latency (typically 100-300ms).

Step 3: Stream Audio to Gemini

The audio needs to be converted from browser format to what Gemini expects:

processor.onaudioprocess = (e) => {
  const inputData = e.inputBuffer.getChannelData(0) // Float32 audio
  
  // Convert float32 to int16 (Gemini's expected format)
  const int16Data = new Int16Array(inputData.length)
  for (let i = 0; i < inputData.length; i++) {
    const s = Math.max(-1, Math.min(1, inputData[i]))
    int16Data[i] = s < 0 ? s * 0x8000 : s * 0x7FFF
  }
  
  // Convert to base64 and send
  const base64Audio = btoa(String.fromCharCode(...new Uint8Array(int16Data.buffer)))
  session.sendRealtimeInput({
    audio: {
      data: base64Audio,
      mimeType: "audio/pcm;rate=16000"
    }
  })
}

This runs in a loop (every 4096 audio samples, roughly every 256ms), continuously sending audio chunks to Gemini.

Why Gemini Live Instead of Whisper?

You might wonder why not use OpenAI's Whisper. A few reasons:

  • Latency: Whisper processes audio in chunks (typically 30 seconds). Gemini Live transcribes in real-time with ~200ms latency
  • Streaming: Gemini Live is built for streaming. Whisper isn't
  • Cost: Gemini Flash is extremely cheap for audio transcription
  • Simplicity: One WebSocket connection handles everything. No need to chunk, buffer, and batch audio yourself

Whisper is more accurate for difficult audio. But for clear interview audio, Gemini Live is more than good enough, and the speed advantage is massive.

Conclusion

So there you have it, $800 saved and you've got a tool that's essentially invisible to screen sharing, transcribes in real-time, and floats above your interview window.

The code's open source, so take it, modify it. Now you know how to build an invisible, undetectable desktop overlay that can transcribe audio in real-time.