Plugins

This guide explains what plugins are in Revolution EDA, how users install and use them, how developers create them, how config.json works, and how plugins are published to the Revolution EDA plugin registry.

Quick Orientation

• Plugins extend Revolution EDA without changing the core application.
• End users typically encounter plugins as extra menu items, new editor actions, or support for additional view flows.
• Browse available packages through Plugins → Browse Plugins… in the main window.
• Developers package plugins as Python packages with a config.json file and callable callback functions.

What Plugins Are

Plugins are add-ons that extend Revolution EDA without modifying the core application. Typical plugin categories are:

• Simulation workflows
• Result plotting tools
• AI-assisted design tools
• Schematic-driven layout synchronization
• Custom view handlers and editor menu actions

In daily use, plugins usually appear as additional menu actions in editors or as handlers for specific view types.

How Plugins Are Loaded

At startup, Revolution EDA loads plugins from the directory configured by REVEDA_PLUGIN_PATH.

• The loader scans that directory with pkgutil.iter_modules().
• The loader reads each package’s config.json and checks API and core-capability compatibility before importing it.
• Compatible packages are imported; incompatible plugins are skipped and reported in reveda.log.
• The configuration also wires up editor menu actions.

Important:

• If REVEDA_PLUGIN_PATH is not set, the application falls back to ~/.reveda/plugins/.
• Set the plugin directory through application setup, then restart the application. The main-window Plugins → Browse Plugins… menu opens the registry.

Plugin Folder Structure

Each plugin should be a Python package under the plugin directory:

<plugins_path>/
  myPlugin/
    __init__.py
    config.json
    <implementation>.py
    README.md            (recommended)

Minimum required files:

• __init__.py so Python can import the package
• config.json for metadata and menu definitions

Using Plugins (End Users)

Most users only need three steps:

1. Open the plugin registry UI from Plugins → Browse Plugins….
2. Install the plugin you want.
3. Restart Revolution EDA.

Install from Plugin Registry UI

1. Open Plugins → Browse Plugins… in the main window.
2. The Plugin Registry fetches published package metadata from https://plugins.reveda.eu/plugins.json. As of 8 October 2026 it lists RevSDL for Linux x86_64, but not AI Terminal, RevedaSim, or RevedaPlot; check the catalog for updates and compatible builds.

3. Select a plugin and click Download / Install.
4. After a successful installation, choose Restart Now to activate it immediately or Later to keep working.

Commercial plugins install the required revedaLicense module first when it is not already present; the selected plugin download resumes automatically afterward.

Notes:

• source plugins use a single url field in the registry.
• binary plugins can provide binary_urls; the app chooses the best URL for your OS, CPU, and Python version.

Uninstall

1. Open Plugins → Browse Plugins….
2. Select an installed plugin.
3. Click Uninstall.
4. Restart Revolution EDA.

Manual Install

1. Copy plugin folder into your configured plugins directory (REVEDA_PLUGIN_PATH).
2. Ensure plugin contains __init__.py and config.json.
3. Restart the app.

config.json Explained

The plugin loader reads each plugin’s config.json and uses menu_items to inject menu actions.

What config.json Actually Does At Runtime

The loader discovers packages by folder name, reads <plugin>/config.json before importing them, and checks compatibility first. Compatible plugins are imported, then menu_items registers UI actions; missing callbacks are skipped.

What is required for menu wiring:

• menu_items list
• For each item: location, menu, action, callback; apply must name the actual target window classes.

Optional compatibility fields include plugin_api, min_app_version, max_app_version, requires_core, and provides. plugin_version is used for update notices. license and license_required also control callback licensing for commercial plugins.

Version and capability negotiation

An incompatible plugin is skipped before its code is imported; reasons are logged in reveda.log. Plugins without declared constraints use the original API 1 menu-callback contract. The current core implements plugin API 2. Use provides to declare capabilities such as sdl, and requires_core for dependencies such as sdlAdapterV1. An installed compatible provider remains visible even if its commercial actions require activation.

Discovery and update checks

The application menu has Plugins → Browse Plugins… and Updates (N). An optional discovery banner can be dismissed for 90 days. Once a day, a background check compares installed plugin_version values against the registry; updates are highlighted in the catalog, and REVEDA_DISABLE_UPDATE_CHECK disables the background request.

Example:

{
  "plugin_name": "myPlugin",
  "plugin_version": "0.1.0",
  "description": "Example plugin",
  "license": "Mozilla Public License 2.0",
  "author": "Your Name or Company",
  "menu_items": [
    {
      "location": "menuBar",
      "menu": "Tools",
      "action": "My Action",
      "text": "Run My Action",
      "callback": "runMyAction",
      "shortcut": "Ctrl+M",
      "checked": 0,
      "apply": ["schematicEditor", "symbolEditor", "layoutEditor"]
    }
  ]
}

Key fields in menu_items:

• menu: existing menu name where action is added (for example Tools, Simulation, Results)
• callback: function name in plugin module (__init__.py imported symbols)
• apply: list of window class names where action is visible
• Optional: text, icon, shortcut, checked, read_only_safe. Actions default to mutating and are disabled when the editor is read-only due to a design lock; mark non-mutating actions read_only_safe: true.

Commercial menu licensing

Commercial actions are installed as menu items but gated when selected. Without an entitlement, the license dialog opens before the callback runs. License state does not remove a compatible plugin’s capability or its menu actions.

Free access until April 1, 2027: All four first-party plugins—aiTerminal, RevedaPlot, RevedaSim, and RevSDL—are free to use until April 1, 2027 at 00:00 UTC. No paid license or activation key is required during this period. You still need to install a compatible plugin build; external AI API usage and circuit simulators are not included. This offer does not apply to third-party plugins. After the cutoff, normal commercial licensing applies.

Real Examples

aiTerminal example:

• aiTerminal/config.json adds AI Terminal under Utilities in the schematic, symbol, and layout editors.
• The toggleAITerminal callback opens the licensed terminal panel.
• Its second menu item adds AI Terminal under Tools in the simulation window.

revedasim example:

• plugins/revedasim/config.json defines Simulation Environment... under Simulation menu for schematicEditor.
• callback is startRevedasim.
• plugins/revedasim/__init__.py exposes startRevedasim.
• plugins/revedasim/simMainWindow.py implements def startRevedasim(schematicEditor): ....

Important distinction:

• config.json does not define view-type dispatch.
• View dispatch uses plugin module attributes/functions such as viewTypes, createCellView, and openCellView (as used by revedasim).

Practical rules:

• Keep plugin folder name and importable package name consistent.
• Ensure callback functions are exposed and importable.
• Keep import side effects minimal to avoid startup failures.

Creating a Plugin

1. Create a package directory under your plugins path.
2. Add __init__.py with callable functions used by menu callbacks.
3. Add config.json with metadata and menu_items.
4. Test by restarting Revolution EDA and checking reveda.log.
5. If needed, add support for view opening by exposing viewTypes plus createCellView and/or openCellView in the plugin module.

Minimal __init__.py example:

def runMyAction(editor_window):
    editor_window.logger.info("My plugin action executed")

Plugin Registry (plugins.json) Format

The active registry is served at https://plugins.reveda.eu/plugins.json. It contains a top-level plugins list; each entry provides a name, version, license, description, package type, and download locations. For binary plugins, binary_urls selects a build by operating system, architecture, and Python version (for example linux-x86_64-py3.14). Do not assume that a plugin described on this site is already listed or has a compatible build in the catalog.

Plugin authors should package a ZIP that extracts into the plugin folder, provide matching config.json metadata, and test callback imports and supported platforms. Publishing is repository-based — there is no in-app upload: clone revolutionEDA_plugins, add the ZIP file(s) plus a plugins.json entry, and open a pull request describing the plugin name, version, license, download URLs, and tested platforms. Plugins may carry their own license terms, independent of Revolution EDA’s licensing. After merge, users can install the plugin from Plugins → Browse Plugins…. Restart the application after installing or updating a plugin.

Troubleshooting

Plugin not shown:

• Verify REVEDA_PLUGIN_PATH points to the correct folder.
• Verify plugin folder contains __init__.py and valid config.json.
• Restart app after install/uninstall.

Plugin found but action missing:

• Check menu name matches an existing menu in target window.
• Check apply includes the actual editor class name.
• Check callback function exists in the plugin module.

Import/load failure:

• Inspect reveda.log for Failed to load plugin ... errors.
• Install missing Python dependencies in the same environment used by Revolution EDA.

Related Files

• reveda.py
• revedaEditor/backend/pluginsLoader.py
• revedaEditor/gui/pluginsRegistry.py
• plugins.json
• Binary Plugins guide.

• Email (click to reveal)
• Tamboershof 2
  Huissen, 6852 PC
  Netherlands