blog.bloomca.me
Limitations
Excerpt
Electron is a cross-platform framework which allows to develop Desktop applications. They are “native” in a sense that you will build and package the installer for your users, but the integration with OS is limited to what the framework provides, and making custom integrations is not trivial, because the application logic is written in JavaScript and executed by Node.js, so if you want to access OS capabilities, you’ll need to write a Node addon. We’ll talk about that later, but it is not the most straightforward thing, although it can definitely be done. … Shipping the browser also means that we ship its security model. Back in the day, a single JS crash would kill all browser tabs, but today each tab crashes independently. In Electron, this means that every window is its own process and there is no easy way to share data between each window. There is IPC helper implementation, and if each of your windows is on the same domain, you can use broadcastChannel API, but that is inter-process communication with its own set of downsides like non-shared memory and no way to pass any non-standard data. Another thing to keep in mind is that Electron is normally a pre-compiled binary, and that is what the final binary application is unless you compile the source code by yourself. This means that it if you need to handle some OS-level events (e.g. extend AppDelegate on macOS), you might need to re-compile Electron with your native code statically linked. … At this point, you might ask: “well, why would I actually use Electron?”. The main reason to use Electron is that despite all the drawbacks, it is a truly cross-platform framework which minimizes differences between platforms. For example, Tauri (at least at the time of writing, July 2025) relied on the system WebView (essentially Microsoft Edge on Windows and Safari on macOS) and uses Rust to compile the app code to machine instructions, which allows the binaries to be very compact, like ~10-20MB vs ~50-90MB with Electron. However, the system WebView can be very different on Windows 8 vs on some Linux distro vs very old macOS version. This is especially bad on Linux (see this GH Issue), but debugging issues specific to old OS versions is not fun on Windows and macOS as well. Interesting that Tauri is exploring including the frontend runtime with the binaries (ref) to help with this exact issue, but it will definitely increase the size.
Related Pain Points
Poor OS integration and missing platform features
7Electron apps don't integrate well with operating systems because they're essentially web browsers displaying local content. When Electron doesn't support specific OS features, apps using it also won't—for example, Discord lacks screen sharing on Wayland and doesn't support file portals on Flatpak.
Excessive memory and disk space consumption
7Electron apps bundle most of Chromium's codebase, making even basic Hello World applications ~100MB and real-world apps like Discord over 700MB. This excessive resource usage creates performance problems on systems with limited RAM.
Complex inter-process communication between Electron windows
5Each Electron window runs as a separate process with no easy way to share data between them. IPC implementation and broadcastChannel API have limitations like non-shared memory and inability to pass non-standard data types.
Platform inconsistency compared to Tauri's system WebView approach
5While Electron provides true cross-platform consistency by bundling Chromium, alternatives like Tauri rely on system WebViews that vary significantly across OS versions (particularly problematic on Linux), creating debugging challenges. Tauri's approach yields much smaller binaries (10-20MB vs 50-90MB).