Revolution EDA Schematic/Symbol/Layout Editors and Simulation and Analysis Environment

Introduction

Revolution EDA is a new generation of schematic and symbol editor targeting custom integrated circuit design with integrated simulation and plotting capabilities. Current version is 1.0.0.

Core Features

1. Advanced Symbol Creation: Create symbols with both common symbol attributes and instance parameters. Instance parameters can be Python functions for dynamic parameter calculation.
2. Automatic Symbol Generation: Generate symbols automatically from schematics and Verilog-A modules with support for circles, lines, rectangles, and arches.
3. Verilog-A Integration: Clear separation between model and instance parameters for Verilog-A symbols.
4. JSON-Based File Format: Human-readable JSON format allows easy inspection and editing with text editors.
5. Configuration-Driven Netlisting: Config view support similar to commercial tools for choosing simulation views.
6. Hierarchical Netlisting: Full hierarchical netlisting capability with support for Xyce, Spectre, and VACASK simulators, including bus and instance array netlisting. Subcircuits can be parsed directly from Spectre (.scs) and VACASK (.vacask) files to generate symbols automatically.
7. Python-Powered Labels: Labels support Python functions enabling professional PDK development.
8. Layout Editor: Full-featured hierarchical layout editor with support for rectangles, polygons, paths, pins, labels, vias (single and array, with per-via bottom/top metal enclosure and min-enclosure validation), and python-based parametric layout cells. Includes layer management (selectability and visibility management, plus a "show only used layers" filter), edge-snapping rulers, GDS/OAS import/export, and initial Schematic Driven Layout (SDL) support.
9. Comprehensive Library Management: Familiar library browser for creating, renaming, copying, and deleting libraries, cells, and views.
10. Library Registry: Built-in registry UI (Tools → Libraries) for downloading Revolution EDA-compatible design libraries directly from the GitHub library registry.
11. Plugin Registry: GUI-based plugin installer (Tools → Plugins → Setup Plugins…) that downloads and installs plugins from the Revolution EDA plugin registry.
12. PDK Registry: GUI for registering and switching PDKs without editing configuration files manually.
13. AI Terminal: Natural-language design modification through the latest-generation ChatGPT (OpenAI), Gemini (Google), and Claude (Anthropic) backends; API keys are stored in encrypted form.
14. Parasitic Extraction (PEX): Built-in RC extraction engine (revedaEditor/rcextraction/) that computes parasitic resistance and capacitance from an LVS "Export for PEX" database (.rcx.json). The engine is pure Python, independent of the GUI, and writes extracted netlists in SPICE, SPEF, Spectre, and VACASK formats with technology/corner support.
15. Integrated Python Console: Full Python REPL in the main window for automation and scripting against Revolution EDA's internal APIs.
16. Stipple Pattern Editor: Built-in editor for creating custom layer fill stipple patterns.
17. Persistent Configuration: Save and restore configuration parameters per project.
18. Project Management: Project-directory-based workflow with per-project .env, library.json, and reveda.conf. Switching projects triggers a clean application restart to ensure PDK and plugin modules are loaded fresh. Recent projects are tracked and accessible from the File menu.
19. Constrained Move: Move items with orthogonal and diagonal constraints across all editors using Shift+M shortcuts.
20. Net Probing: Probe nets with multi-color highlighting over the circuit schematic hierarchy,
21. Export Graphics Export schematics/layouts to SVG, EPS, and high-quality raster images (including black-and-white output for printing) for publication-quality schematic, layout and plot output.
22. Plugin Licensing: Ed255-signature-based license validation for commercial plugins with machine-fingerprint activation and checkout workflow.
23. Comprehensive Logging: Error, warning, and info message logging to reveda.log.

Plugin Architecture

Revolution EDA features a modular plugin architecture that enables extensible functionality. Plugins can add their own menus and actions to editor windows through a config.json declaration — no changes to the core codebase are required.

There are already several plugins available, including revedasim, revedaplot, and aiTerminal. Proprietary plugins can be distributed as pre-compiled binaries alongside source-available plugins.

Simulation and Plotting

Revolution EDA Simulation and Analysis Environment (revedasim)

• Multi-Simulator Netlisting: Full support for Xyce, and VACASK circuit simulators, including subcircuit parsing and automatic symbol generation from Spectre (.scs) and VACASK (.vacask) source files.
• Parameter Sweeps: Multi-dimensional parameter sweep capabilities
• Analysis Types: Xyce supports DC, AC, transient, noise, and harmonic balance analyses. VACASK additionally supports transient noise (trannoise), DC incremental (dcinc), DC transfer function (dcxf), AC transfer function (acxf), AC stability (acstb), and AC S-parameter (acsp) analyses.
• Output Management: Flexible output signal selection and processing
• Process Management: Efficient simulation job management

Revolution EDA Plotter (revedaplot)

• Very Fast: Can handle very large datasets.
• Imports both Raw and Ascii file output: Can uniformly handle raw and ascii file formats generated by Xyce and other circuit simulators.
• Interactive Waveform Viewer: Advanced plotting with zoom, pan, and measurement tools
• Multi-Plot Support: Combined and separate plot views
• Parameter Sweep Visualization: Automatic plotting of parametric simulation results
• Export Capabilities: High-quality plot export functionality

AI Terminal (aiTerminal)

• Natural-Language Design Editing: Modify schematics, symbols, and layouts using conversational requests sent to an AI model.
• Multiple AI Backends: Latest-generation ChatGPT (OpenAI), Gemini (Google), and Claude (Anthropic) supported.
• Secure API Key Storage: Keys encrypted with Fernet and stored under ~/.reveda/.
• Automatic Backup & Undo: A backup is created before every AI modification; one-click restore via the undo command or Undo Changes button.
• Read & Inspect: Run read to display the current design JSON directly in the terminal.

Parasitic Extraction (RCX/PEX)

Revolution EDA ships a vendored RC parasitic extraction engine in revedaEditor/rcextraction/. It is pure Python with no third-party runtime dependency and is intentionally free of any revedaEditor imports so the extraction logic stays independent of the GUI.

• Extraction Database: Consumes a .rcx.json database produced by the LVS "Export for PEX" step (rcxExport).
• Technology and Corners: Layer R/C models and corners are loaded from a technology file (tech).
• Engine: The extractor.extract entry point computes parasitic R and C.
• Output Writers: netlist.get_writer produces extracted netlists in SPICE, SPEF, Spectre, and VACASK formats.

Installation

Prerequisites

• Python 3.12, 3.13, or 3.14
• Poetry if installing from source

From PyPI

pipx install revolution-eda

The current total of downloads in PyPi repository is:

After installation, start the program with:

reveda

To open a specific project directory:

reveda --project /path/to/my/project

From Source

# Clone the repository
git clone https://github.com/eskiyerli/revolution-eda.git
cd revolution-eda

# Install dependencies
poetry install

# Run the application
poetry run reveda

Binary Releases

Standalone binaries built with Nuitka are available on the GitHub Releases page and do not require a separate Python installation. The binaries launch as GUI applications without a console window.

• Windows: reveda.exe
• Linux: reveda.bin (mark executable with chmod +x reveda.bin before running)

Both support the --project argument:

reveda.exe --project C:\Users\me\designs\my_project

PDK Installation

To use the preliminary IHP PDK, clone the ihp_pdk repository:

git clone https://github.com/eskiyerli/ihp_pdk.git

Set the REVEDA_PDK_PATH variable in the .env file to the cloned directory. If both repositories are cloned side-by-side, the .env entry would be:

REVEDA_PDK_PATH=../ihp_pdk

PDKs can also be registered and switched through the PDK Registry dialog (Tools → PDKs → Setup PDKs…) without editing .env directly.

Example Libraries

Clone the exampleLibraries repository for a set of ideal elements and IHP sg13g2_pr library cells (including pcells for rsil, cap_cmim, and sg13_lv_nmos):

git clone https://github.com/eskiyerli/exampleLibraries.git

Use the Library Registry (Tools → Libraries) to download additional Revolution EDA-compatible libraries directly from within the application.

Documentation

Full documentation is available in the docs/ directory and covers:

• Installation
• Main Window
• Schematic Editor Tutorial
• Symbol Editor Tutorial
• Layout Editor Tutorial
• Config Editor
• AI Terminal
• Plugins
• Labels
• Binary Plugins

License

Revolution EDA is licensed under the Mozilla Public License 2.0.

This is a free and open-source software license that allows you to:

• Use the software for any purpose
• Modify the source code
• Distribute the software and your modifications
• Sell products and services that incorporate Revolution EDA
• Create commercial derivatives and rebranded versions

The MPL 2.0 is a weak copyleft license that requires:

• Making source code modifications available under the same license
• Preserving license notices in distributed copies
• Not using the Revolution Semiconductor trademarks without permission

Plugin and PDK Licensing

While the main Revolution EDA application uses MPL 2.0, plugins, PDKs (Process Design Kits), and libraries may have their own separate licensing terms. Please check the individual license files for each component.

See LICENSE.txt for the full license text.

Attribution

• Some icons by Yusuke Kamiyamane. Licensed under a Creative Commons Attribution 3.0 License.