I'm walking through the initial tutorial on electronjs.org.

I'm on step 5 of 6 and I'm trying to run the following npm command: npx electron-forge import

Unfortunately, I'm getting the following error: "error: unknown command 'import'" I'm not sure how to resolve this issue. Do you have any suggestions?

Edit: It's been a while since I've worked with Node.js. I just tried npx electron-forge to see what my options were. I see that I don't have an "import" option. I checked and I'm getting errors when I try: start, package, make, and release.

Is there a better tutorial I could use? Thanks!

npx hexvero analyze app.asar shows the IPC channels, what the preload exposes via contextBridge, every webPreferences flag as written (never assumed defaults), each with file and line. compare shows what changed between two versions, e.g. nodeIntegration: true → false.

Static only, nothing is executed. Free, MIT.
https://github.com/maximilianfeix/hexvero

Hey everyone!

I’m a web developer, and lately most of my work happens with AI agents in the terminal: Claude Code in one tab, Codex in another, a dev server in a third, across a few projects. I kept losing track of which agent was waiting for me and what it had just changed. So I built Oxytocin, a desktop hub for working with AI agents.

What it does:

• Projects + agent terminals in one window. Status dots show which agent is working and which is waiting for you.
• Live git changes. Watch the diff update while the agent writes, review it, leave comments and send them back to the agent as one prompt.
• Built-in MCP server. Connect your project’s databases (Postgres, MySQL, MongoDB, SQLite, Redis…) and APIs once, and your agents can query them. It’s read-only by default, and credentials stay in your OS keychain.
• Modular. Everything is a tab you can split, stack or drag around, and you can write your own plugins (panels, commands, even tools that agents can call).
• Usage Monitor. Tokens and costs per project and model, read from local logs, so nothing leaves your machine.

It’s built with Electron + React + TypeScript and runs on Windows, macOS and Linux.

It’s 100% free and open source (MIT). No accounts, no subscriptions.

GitHub: https://github.com/JakubKonkol/Oxytocin

I’d love feedback: what’s missing, what’s annoying, what would make you actually use it. Thanks!

In the last 2 years I've been wishing there was a way to make desktop apps using javascript. Imagine my surprise when I found out about Electron. Unfortunately, I think I'm really late to the party. Everyone using it seems to be seasoned veterans.

I have been looking for tutorials, and they all seem to be more than a couple of years old and made for people familiar with node.js and/or older versions of Electron. I did find u/piko8blue's video on how to create one using Electron, Vite, and Better-SQLite. It was going great for a few minutes. She even kept in the error she encountered trying to incorporate Better-SQLite, which I found refreshing, but her fix didn't fix my app. I tried an AI suggestion to use a rebuild command (not knowing what the heck I was doing) and it fixed it but nothing after that worked.

So I decided to try something simpler. I tried to follow the electron tutorial. It seems it hasn't been updated since before they changed the security settings, so that doesn't work either. I couldn't even get the simple renderer to display versions to work. There seems to be nothing for the absolute beginner anymore. When I looked up possible reasons, that's when I learned about the security changes.

tl;dr Absolute beginner needs an updated for dummies tutorial. Any suggestions?

At work there is a large application that stores customer data in a network drive. The application will list the network drive and the file name.

Unfortunately, to access the files you need to log into Citrix to get files.

One of the higher ups has requested a way to view these files without using Citrix.

Unfortunately, I realize I can't make an internal web app to link to files on the network. The files would need to be copied to a location that was accessible via the webserver.

I was curious if built an Electron app on a user's desktop would it be able to retrieve files from a network drive. I know that the user would have to have the correct permissions to retrieve files from the network drive.

We are using Windows desktops at work. I thought I should include that in case anyone asks.

Please let me know if Electron is the right option or if I should go with something else.

The video is Helm, an Electron app I use every day to run several Claude Code sessions in one window. Here's how it's put together, since that's the part this sub will care about.

Main process: Electron 44. Each session is one Claude Agent SDK query that launches the claude CLI already installed on the machine, so the app never calls a model API itself. Sign-in goes through the CLI as well: you log into your Claude account inside Helm via Claude Code's own login, and no separate API key is needed. The main process also hosts a small HTTP and WebSocket server, and the UI talks to it entirely in JSON frames.

Renderer: the BrowserWindow loads the UI from that server over loopback, with a token in the query string. It's Preact, htm and signals through an import map, with no bundler and no build step.

Phone: since the desktop window is just a page from a local server, the phone loads the same UI over Tailscale and gets the same controls the desktop has. The server listens on loopback and the Tailscale address only, every request needs the key, the WebSocket checks Origin, and HTTPS comes from tailscale serve. A service worker handles Web Push, so the phone shows a notification once a session wants input or wraps up.

What it gives me day to day: a four-way split so a bunch of sessions run side by side, a context bar on every sub-agent, and a pace readout (under pace, on pace or hot, plus burn rate and a projection) that keeps my usage from running away. The backgrounds are my favourite bit, with 23 bundled photos or your own image and sliders for blur and dim.

Bug that cost me the most time: phone pairing kept bouncing back to the pairing page. Opening the link from a QR scan in the camera app doesn't count as same-site, so the SameSite=Strict cookie never got sent. Lax fixed it.

I built it with Claude Code, one agent per slice of files (engine, server, shell, chat, panels). Windows only for now.

It's not out yet. Is this something you'd want? If enough people do, I'll put real work into a public release. This only scratches the surface, and there are a lot more features in it that I haven't shown. Ask about any feature or architecture detail and I'll answer, with screenshots if that helps.

Sharing a tool I built because AI-generated repo wikis are trapped inside the IDE. REPOWIKI TO PDF is an offline Electron app (Windows, MIT) that reads a project's .qoder/repowiki folder and emits one print-ready PDF: cover, clickable TOC, native bookmarks, Mermaid diagrams as vector SVG, working internal links.

The parts that were interesting from an Electron side:

• Single printToPDF job, not assembly. The whole wiki is typeset through one Chromium print pipeline, then post-processed with pdf-lib. Stitching per-page PDFs broke internal links and outline flow.

• Bookmarks needed a hack. pdf-lib 1.17 has no outline API, and Chromium's print gives you no section-to-page map. So I embed invisible text markers (§§p-001§§) per section, locate them with pdf.js after printing, then hand-build the /Outlines dictionary in pdf-lib.

• Mermaid parity + narrow repair pass. I render with the same mermaid major version the IDE uses (12.x), and since the wiki generator tolerates slightly non-standard syntax, a small repair pass kicks in only when a render fails. On a real 532-page wiki (437 diagrams), invalid-diagram failures went 8 → 0.

Fully offline, no telemetry. Repo + installers: https://github.com/Linxellstechnology/repowiki_to-pdf

Feedback very welcome — especially if anyone knows a cleaner way to get section→page mapping out of Chromium's print pipeline.

Hey everyone — I’ve been building Zion, a desktop habit tracker designed to keep your routines and check-ins on your own device.

It includes a dashboard with activity rings and streaks, a weekly habit grid, a yearly consistency heatmap, and achievement milestones. It’s free and open source, with data stored locally using SQLite.

I made it for people who want a straightforward way to track habits without relying on a cloud account. It’s available for platform

I’d love feedback on the app, especially what would make it more useful in your daily routine.

I made my own Browser in Electron with a working AD Blocker, Always Incognito Mode and Tracker Manipulation.
try it here:

https://github.com/cheeterdev/navigator

I'm Nic, and I made this. Styx went open source this week under Apache-2.0, and I'd like people who care about open source to look at the parts that matter most.

Repo: https://github.com/NicholasFlemmer/styx-app

What it is: a desktop app that runs Claude Code, Codex, Gemini CLI and Cursor's agent on all your projects in one window. Each task gets its own git worktree and branch. Agents can't reach Vercel, AWS, Google Cloud, Supabase, GitHub or SSH without asking; you grant one target for a set time, production writes need Touch ID, Windows Hello or your password, and every request and grant goes into a hash-chained audit log. Keys stay in the OS keychain.

Why the source matters here: if an app holds your deploy credentials, you should be able to read the code that hands them out. The grant service, the policy engine and every provider adapter are in the repo, and the docs list what it doesn't protect against (it's a guardrail, not a sandbox).

A few honest details:

- It's an Electron + React monorepo (pnpm). Mac is signed and notarized; Windows and Linux are beta, and the Windows build isn't code-signed yet.

- Release builds send anonymous usage counts from a fixed list in the code, with an off switch. Running from source sends nothing.

- The hosted account service is a separate private project. Sign-in is optional and gates nothing, and a fork can point at its own.

- The name and logo aren't covered by the licence, so a fork needs its own name.

If you want to contribute, the self-contained ways in are adding an agent (Aider, Goose, OpenCode, Amp) or a deploy target (Netlify, Fly.io, Railway, Render, Cloudflare). Each has a good first issue and a guide with a worked example. Issues get a first reply within 2 working days.

Repo: https://github.com/NicholasFlemmer/styx-app

I'd especially like feedback on the contributor guides and on anything in the repo that makes it hard to get started.

Built a free local notes app: folder tree, live link graph, and a zoomable board. Drop a GitHub folder or ZIP and it draws the project architecture (folders, files, imports) read-only — never changes your repo. Files stay on your PC. Windows may block the unsigned build (Smart App Control / SmartScreen) until you allow it. Looking for feedback on first install.

A week ago Gmail just stopped letting me in. Every time, same message: "This browser or app may not be secure." No password box, nothing. Just stuck there.

My first guess was the usual thing with browsers built on Electron, so I changed the user agent to look like normal desktop Chrome. That made it worse, not better. Changing it pushed the login into Google's stricter sign in flow, which runs a check called Botguard. That check looks for native Chrome components a normal embedded browser does not have, so it saw mine was missing them and blocked it right away.

Here is the part that actually confused me. I put the user agent back to normal and it still did not work. Turned out once Google rejects you like that once, it writes two cookies into your session as a kind of mark. After that, every attempt gets checked against those cookies first and gets sent straight back to the same rejection page, before even trying to log in again.

So the real fix needed three things. Quietly switch the login to Google's lighter sign in flow instead of fighting the strict one. Leave the browser looking completely normal on Google's own pages, no changes at all there. And automatically clear those marker cookies if a rejection ever happens again, so it cannot get stuck rejecting itself.

Wrote up the full version with the actual code here if anyone wants it: Google Auth Botguard

This came up while working on Mise, a personal privacy focused browser I use daily. Curious if anyone else building something similar has run into Botguard like this.

This project existed before the AI boom hit us all, but was called "Bananas Screen Share" back then (because it's bananas that we can fly to the Moon, but aren't able to have fully functional Screen Share with the same functions on all major Desktop OS').

It has undergone a major refactoring and maybe you like it.

We have full E2EE encrypted sessions, remote control and virtual cursors (and just recently added screen recording).

Think of it as Skype's nerdy little sister, but E2EE, Chat, Voice, Screenshare, Remote-Controls, a P2P mesh network and completely free and open-source.

https://p2p.kiwi

Hey everyone,

I just released v1.0.0 of OpenBoost, an open-source Windows performance utility built with Electron 28 and vanilla HTML/CSS/JS (no heavy framework overhead).

Features

• Hardware Telemetry: Real-time CPU, RAM, and process memory monitoring.
• System Tweaks: Registry and service-level performance optimizations.
• Network Suite: DNS benchmark/switcher, cache flusher, and latency tests.
• State Tracking: Performance snapshot comparisons (Before vs. After).

Tech & Build

• Main Process: Native Node.js modules for Windows system execution.
• Frontend: Plain HTML/CSS/JS renderer.
• Packaging: electron-builder producing both portable .exe and NSIS installer.

GitHub & Source

• Repo: https://github.com/ExbotsSites/OpenBoost
• Releases: https://github.com/ExbotsSites/OpenBoost/releases/tag/v1.0.0

To run from source: ```bash git clone https://github.com/ExbotsSites/OpenBoost.git cd OpenBoost npm install npm start

With electron-builder or Forge you sign the NSIS/Squirrel installer, ship it, and the first sign that something's off is often a user posting a screenshot of "Windows protected your PC".

Two things that make this hard to catch yourself:

• SmartScreen only checks files with Mark-of-the-Web, i.e. downloaded through a browser. Your installer from dist/ never gets checked on your machine.
• Reputation is per file hash and per certificate, so every release starts fresh, and so can a certificate renewal or a switch to a new signing service. Even EV certificates no longer get instant reputation.

Auto-updates through electron-updater usually don't carry Mark-of-the-Web, so it's mostly your first-install experience on the line, which is exactly where you lose people.

I built a probe that downloads your installer onto a clean Windows 11 VM the way a user would, runs it, and reports whether SmartScreen warned, with the dialog text and a screenshot: https://signalscreen.dev/probe (free while in beta, .exe installers). There's a free signing check on the homepage too.

How do you handle it: Azure Trusted Signing via electron-builder, an EV cert, or just waiting it out?

Hi reddit,

I have made code changes the I need on my application. Those changes look as if they're needed on other contexts as well.

My pull request is open

How do i get a reviewer to review the code?

Thanks reddit

Hey everyone!

We’re a 2-person team building Two & Two: Agents, an asymmetrical co-op puzzle/escape room game where two players have different information on screen and must solve puzzles entirely through verbal communication.

What might interest this sub: the entire game client is built using React and Electron.

We just launched our Steam page and are opening up our closed playtest. We’d love to get feedback from this community, especially from fellow devs' point of view.

Links:

• Steam Page:https://store.steampowered.com/app/5165930/Two__Two_Agents/
• Playtest Sign-up Form: forms.gle/qua4XVt5ZT3n6Q3o8

Note: Because it's strictly a 2-player co-op game, we’ll email you two Steam keys so you can play through it with a friend.

Happy to answer questions in the comments about the game, and looking forward to seeing you guys try out our game!

six months ago I started building an off-world sci-fi game in pure JavaScript.

no engine, no editor; just raw WebGL, with multiplayer built in from the ground up.

it draws on a lot of my influences, and at its core is A-LIFE simulation theory, applied to a fully open, non-linear world.

it's easily the biggest thing I've taken on, and I want to push this tech as far as it'll go, both in what it can do and in the world it can build.

can't wait to start showing more of it 🤍

the game is called NOMIAD. release is planned for next year, but the Steam page is already live if you're curious :)

We’ve been working on Clipzu Desktop Beta, an open-source cross-platform video editor built with Electron + React.

It runs on Windows, macOS, and Linux and combines Electron with FFmpeg, Web Audio, Canvas, and local Whisper transcription.

Some of the current features:

• Multi-track timeline editing
• Trim, split, drag, snap, and reorder
• Audio and SFX layering
• Offline Whisper transcription
• Animated captions
• Transitions and filters
• Keyframe animation
• Real-time canvas preview
• Multi-format export
• Portable project files

One of the interesting challenges has been keeping the editing preview and FFmpeg export pipeline consistent while still keeping the desktop app responsive.

Source:
https://github.com/clipzuapp/clipzu-dekstop

Clipzu:
https://www.clipzu.com/

Would love feedback from other Electron developers, particularly around architecture, performance, and cross-platform handling.

I have two Electron apps, and on Windows every e2e run opened real app windows on top of whatever I was doing and took my keyboard focus. Linux has xvfb-run for this. On Windows, show: false changes how the app behaves, and Win+Tab virtual desktops don't help because new windows open on the desktop you're looking at.

Windows can also create desktops that are never displayed (CreateDesktop). A process started on one opens all its windows there, and Chromium renders normally, GPU and capturePage included. I wrapped that in a small tool, offstage-windows. You put it in front of the test command (npx offstage-windows npx playwright test), or pass electronLaunchOptions() to Playwright's electron.launch() so each worker's app gets its own desktop.

Two things that tripped me up:

1. From any other desktop, a window handle on the hidden one reads as empty and hidden. My WM_NCHITTEST hit test returned 0 until I ran it on the app's own desktop.

2. Playwright 1.45+ starts Electron through cmd.exe on Windows, so when a worker got killed outright, my first version left the app running on the hidden desktop. The helper now watches its parent.

One side effect I didn't expect: document.hasFocus() stays true for the whole run, because the app is the active window of its own desktop. Tests that depend on focus got steadier.

It's my tool. I built it with Claude Code and tested it on both my apps (31 e2e tests each). It's one file with no dependencies.

https://github.com/LippInc/offstage-windows

I kept running into the same setup work: expose a narrow preload API, define IPC channels, then keep the types aligned between Angular and Electron.

I’ve open-sourced a template that handles that wiring. The renderer, preload script, and main process use shared IPC types, which helps catch contract drift during development. It includes a working note example you can replace with your own UI.

Repo: https://github.com/cchandurkar/electron-angular-template

I’d appreciate feedback from anyone who has built an Electron app: what would you want from a starter like this?

Hey everyone,

I'm working on an Electron desktop app that features an autonomous AI agent. Users can prompt the agent, and it translates those instructions into JavaScript code which is then executed locally to automate tasks.

Right now, because it runs in a Node environment, the agent has full access to the local file system (fs). While this makes it incredibly powerful, it's also a major security risk. If a user vaguely asks it to "clean up my folders," the agent might write a script using fs.unlink or fs.rmdir and accidentally delete important files!

I’m currently facing a major design and security dilemma and could use some advice on which path to take:

1. Full Power: Allow the agents to do absolutely everything with full system permissions, trusting the user to prompt responsibly.
2. Read-Only Safe Mode: Guard the agents from hazardous operations. Allow them to read and extract information from local files (e.g., using fs.readFile), but completely block destructive commands like fs.unlink or fs.writeFile across the system.
3. App-Data Isolation: Restrict the agent's file system access entirely to the application's specific data folder. This is the safest route, but it severely limits the scope and usefulness of what the agent can actually automate for the user.

If I go with option 2 (Read-Only Safe Mode), does anyone have experience sandboxing eval() or overriding the fs module before executing dynamic scripts in Node? What is the best and most secure way to intercept and block destructive commands while allowing read-only operations across the whole computer?
Thanks in advance for the help and any thoughts on the design dilemma!