Pyloid is a framework that packages Python applications as desktop applications: it connects the front end (HTML/CSS/JS, any framework is acceptable) and the back end Python through a thread-safe RPC, supporting multiple windows, single/multiple instances, window customization, cross-platform (Windows/macOS/Linux), and has a clean and intuitive code structure. In simpler terms, it allows Python developers to write desktop apps as easily as writing Flask applications, but with performance close to native.
What Pain Points Does It Address
- • Bulky Size: Compared to the entire Chromium+Node setup of Electron, Pyloid is lighter (depending on the underlying Qt size, but usually closer to native).
- • Difficulty in Python ↔ JS Communication: Pyloid provides thread-safe RPC, allowing calls to remote functions as naturally as local function calls, without the need for manual serialization or handling event loop conflicts each time.
- • Complicated Multi-window/Multiple Instance Support: Built-in support with simple configuration.
- • Insufficient Desktop Features: Window customization, cross-platform compatibility, and exposing native functionalities to the front end are all built-in.
- • Development Experience: The code structure is intuitive, and the documentation features NumPy-style docstrings, making it easy to get started and reuse.
Key Features Overview
| Feature | Description |
| Supports All Front-end Frameworks | React / Vue / Svelte / Pure JS / Any framework that can output static web content. |
| Python ↔ JS RPC | Thread-safe, allowing remote function calls as if calling local functions. |
| Multi-window & Single/Multiple Instances | Built-in support with flexible configuration. |
| Deep Window Customization | Control over title bar, size, style, transparency, etc. |
| Cross-platform | Windows, macOS, Linux. |
| Clear Code Structure | Easy to maintain and extend. |
| NumPy-style Docstrings | Developer-friendly, easy to reference. |
Installation and Quick StartPreparation: First, install Node.js and Python. Additionally, Pyloid depends on PySide6 (based on Qt) and something called uv (usually a uvicorn-style dependency? Prepare according to official instructions). The steps are straightforward:
- 1. Global Preparation (similar for Windows/macOS/Linux)
- • Install Node.js (LTS recommended).
- • Install Python (3.8+ recommended).
- • npm create pyloid-app@latestThis command will help you generate a starter template, which already includes the front-end directory, Python back end, and packaging scripts.
- • Enter the project directory, npm install (or yarn) to install front-end dependencies.
- • Start the back end (usually python main.py or a similar command).
- • Start the front end (npm run dev).Pyloid will handle the RPC connection between the front and back ends; you just need to write the pages and business logic.
(Note: For specific commands and configurations, please refer to Pyloid’s README or the package.json / pyproject configurations in the template.)
Example: Registering a Function in Python for Front-end CallsHere’s a small example: you write a function get_data in Python, and the front end can directly call it to retrieve data. Pyloid exposes such functions via RPC, ensuring thread safety, so you don’t have to worry about blocking the UI. — We won’t include a long code block here; the template contains a complete example.
Advantages
- • Lighter and closer to native packaging size (compared to pure Electron).
- • Low entry cost for Python developers, with back-end logic reusable from existing codebases.
- • Freedom in front-end frameworks and high design flexibility.
- • Thread-safe RPC and friendly event model, reducing the hassle of asynchronous callbacks.
- • Built-in support for multi-window, multiple instances, and window customization, eliminating the need to reinvent the wheel.
Disadvantages / Limitations
- • Dependency on PySide6 (Qt) introduces some size and native dependency issues, requiring attention to licensing and compatibility during packaging (PySide6 is LGPL).
- • If your application heavily relies on Chromium-specific features (like advanced media encoding/decoding, specific Web APIs), Pyloid’s WebView capabilities depend on the system and PySide’s implementation, which may vary.
- • The ecosystem and community are not as large as Electron’s; encountering very niche issues may require digging into the source code or PR.
- • Packaging and signing still have detail issues across different platforms, especially macOS notarization (not unique to Pyloid, but worth noting).
Practical Advice / When to Choose Pyloid
- • Recommended Scenarios: You are a Python developer who wants to retain a lot of Python business logic while quickly creating a beautiful interface with existing front-end; you care about application size and native feel; you need multi-window or deep window behavior customization.
- • Not Recommended Scenarios: Your product heavily relies on Chromium-exclusive features, or you already have a mature Electron packaging pipeline and your team is familiar with Electron (migration costs need to be assessed).
ConclusionPyloid encapsulates many tedious aspects of desktop application development: thread-safe RPC, front-end framework agnostic, multi-window support, window customization, cross-platform compatibility… For teams and individual projects that prefer Python, Pyloid is a great choice for quickly turning prototypes into “product-level desktop applications.” The main drawbacks are the underlying dependencies (Qt/PySide) and community maturity, but these do not pose fatal issues for most small to medium projects. If you’re looking to replace Electron, it’s worth a try.
Project Address: https://github.com/pyloid/pyloid