Tauri Plugin Python

By default, the plugin includes a set of permissions that allow basic interaction with the Python runtime. The default permission set includes:

• allow-call-function
• allow-read-variable

The plugin supports two backends. Choosing the right one depends on your compatibility and deployment requirements.

PyO3 / CPython (Default)

• Pros: Full library compatibility (supports C extensions like numpy, pandas); fast performance.
• Cons: Requires libpython to be available on the target machine; more complex deployment.
• Best for: Applications requiring heavy data science libraries or complex Python ecosystems.

RustPython

• Pros: Trivial deployment (single self-contained binary); no Python installation required on the target.
• Cons: Limited compatibility (pure-Python only); missing/incomplete standard library modules; slower performance.
• Best for: Simple logic, fast prototyping, or when a single binary is a priority.

By default, the plugin is restricted to prevent arbitrary code execution:

• Function Registration: Python functions can only be called if they are registered from Rust during plugin initialization.
• runPython command: This command (which allows injecting Python code directly via JavaScript) is disabled by default via permissions.
• register command: This command (which allows adding new callable functions from JavaScript) is disabled by default.

Recommendation: Ensure your user interface is not accessible via a network URL in production to prevent unauthorized code injection.

To run the provided Vanilla JavaScript example, follow these steps in order:

1. Prerequisites: Ensure you have rust, python, and nodeJs installed.
2. Base Setup: Navigate to the project root and install/build the plugin dependencies:

   cd ../../
   npm install
   npm run build

3. Example Setup: Navigate to the example directory and start the app:

   cd examples/plain-javascript
   npm install
   npm run tauri dev

To run on iOS:

1. Initialize the iOS project files:

   npx @tauri-apps/cli plugin ios init

2. Start the application in development mode:

   npm run tauri ios dev

# Base path setup
cd ../../
npm install
npm run build

# Example path setup
cd examples/plain-javascript
npm install
npm run tauri dev

When a Python call fails, the plugin returns the error as a rejected promise. You should wrap your calls in a try...catch block to capture the Python error message or traceback.

In development builds (tauri dev), the plugin also prints the full Python traceback to stderr, prefixed with [tauri-plugin-python]. In release builds, errors are not logged to the terminal to prevent leaking information to end users.

try {
  await call.greet_python("input value");
} catch (err) {
  console.error(err); // contains the Python error message / traceback
}

Since PyO3 uses a shared libpython by default, deployment requires providing the library on the target machine.

Recommended Approaches:

1. Ship the venv: Include the .venv folder as a Tauri resource so libpython is bundled with your app.
2. Static Embedding: Use PyOxidizer to embed libpython statically into your binary.

Example: Static Embedding with PyOxidizer:

1. Install: pip install pyoxidizer.
2. Generate artifacts: pyoxidizer generate-python-embedding-artifacts src-tauri/target/pyembed.
3. Update Cargo config to point to the generated file:

# src-tauri/.cargo/config.toml
PYO3_CONFIG_FILE = { value = "target/pyembed/pyo3-build-config-file.txt", relative = true }

The file src-python/main.py is required. All Python files must be included in the Tauri resource configuration (tauri.conf.json). Your bundled resource layout must mirror your local layout so that Python imports resolve correctly.

You can define resources as a list or a source→target map in tauri.conf.json:

"bundle": { "resources": ["src-python/"] }

PyO3 requires a libpython to be available at runtime. The plugin does not have a setting to point to a Python installation; instead, the OS dynamic loader finds libpython via standard search paths (rpath, LD_LIBRARY_PATH, etc.) based on how the plugin was linked at build time.

Deployment Options

1. Ship the shared libpython: Identify which version your binary is linked against (using otool -L on macOS or ldd on Linux) and bundle that library next to your executable.
2. Build against an embeddable Python: Use a standalone Python distribution (like python-build-standalone) at build time via PYO3_CONFIG_FILE, then bundle that Python as a resource.

Note: Bundling a venv (src-python/.venv) only adds site-packages to sys.path; it does not provide libpython.