Story of 'smoodit' (1) : Electron to Tauri

This article documents the story behind the development of text editor named as smoodit, and the lessons learned along the way.

Plan, and starting

The primary objective which I've plan was to implement private-based text editor desktop application with assistant, to boost editing efficiency by offering predictive text capabilities that anticipate user's needs.

On making PoC, I started with Electron platform, which is close to the industry standard. I initially thought about calling external LLM(from ChatGPT, Gemini, Claude...) APIs, but after thinking about offline mode and cost management, I decided to go with an embedded model. After evaluating a few methods, I settled on "Ollama" because of how easily it could be integrated into the workflow.

Why I think of migrating from Electron to Tauri

Electron has been the go-to for desktop apps for years, but its massive resource footprint (thanks to Chromium) started weighing down my project. My application needed to run Python backend and Local LLM engine (Ollama) simultaneously. The requirement to bundle an LLM significantly increased the application's footprint, depending on the model used. This made me much more conscious of the bundle size, which eventually became one of the primary catalysts for my decision to migrate.

For a project where performance and system agility are paramount, Tauri v2 emerged as the clear answer to next step.

• Frontend: React + Vite (leveraging Tauri v2 APIs).
• Backend (Sidecar): A FastAPI server packaged into a single binary using PyInstaller.
• AI Engine (Sidecar): A raw Ollama binary serving local LLMs.

The Migration Roadmap

Phase 1: Mastering the Tauri Sidecar

One of Tauri's powerful features is "Sidecar" — ability to bundle and execute external binaries alongside application core.

• Packaging Python: It used pyinstaller to freeze Python app into a standalone executable and make it run independent.
• Configuration: I registered both backend_server and the ollama binaries in src-tauri/tauri.conf.json under externalBin.
• In Tauri v2, sidecar binaries must include target triple suffix (ex> -aarch64-apple-darwin) in their filenames to be correctly identified during runtime.

Phase 2: Bridging the Frontend and Sidecars

WebView security policies are very strict about local network requests.

• Instead of standard fetch, utilized @tauri-apps/plugin-http plugin. This allows React frontend to bypass CORS issues and speak directly to local FastAPI backend.
• User Experience: Added "Health Check Polling" mechanism. The UI remains in "Initializing" state until the backend sidecar reports status 200 OK, ensuring no requests are lost in the void during startup.

Debugging stories

The most interesting (and stressful) part of any migration is the troubleshooting. Here are several issue I've encountered and how I've fixed.

For MacOS' user — Quarantine

When downloading or bundle third-party binaries, MacOS marks them with a "Quarantine" attribute. When Tauri tried to spawn Ollama, it would fail silently without any visible error.
So, I've added a cleanup step in our package.json build script using xattr -d com.apple.quarantine to strip these attributes from all bundled binaries before execution.

PIPE Buffer Hang

Originally, I've used subprocess.PIPE to capture Ollama's logs in Python. However, when the log data exceeded system's buffer size, the entire Ollama process would freeze (hang).
For this, I've redirected sidecar output to a dedicated log file at ~/ollama_sidecar.log. This not only prevented the buffer-related hangs but also gave us a persistent way to inspect server logs.

Zombie Processes and Lifecycle Management

Also, I've struggled with Ollama instances status staying alive after application closed (zombie processes) because it was running on separate process.
So I've used start_new_session=True in Python subprocess spawn, to detach child from the parent session. Furthermore, I've implemented socket-based port check to verify if the port was truly bound before declaring the server ready.

So, was this worth it?

The results speak for themselves. The installation package size plummeted compared to the Electron version, and memory usage is significantly lower. The combination of a React UI and the speed of Tauri v2, backed by the raw power of Python and Ollama, makes for a truly premium developer tool experience.