gEDA
gEDA, an acronym for GPL Electronic Design Automation, is a suite of free and open-source software applications designed for electronic design automation (EDA), encompassing tools for electrical circuit design, schematic capture, attribute management, bill of materials generation, netlisting in over 20 formats, analog and digital simulation, and printed circuit board (PCB) layout.[1] The project aims to provide professional-quality capabilities for designing PCBs of low- to mid-level complexity, supporting up to 8 layers with unlimited components and nets, making it suitable for students, hobbyists, and professionals in electronics.[1] Developed primarily for POSIX-compliant systems like GNU/Linux, gEDA emerged in response to the scarcity of free EDA tools available for such platforms in the late 1990s.[2] It is released under the GNU General Public License (GPL), ensuring all components are freely modifiable and distributable.[1] Key tools within the suite include gschem for creating and editing schematics, gnetlist for generating netlists to interface with other EDA software, gattrib for managing component attributes, and the standalone PCB application for board layout and routing.[1] Additional utilities support simulation via integrations like gnucap for analog circuits and Icarus Verilog for digital designs.[1] While gEDA represents a mature and influential effort in open-source hardware development, the project is no longer actively maintained as of the early 2020s.[2] Developers and users are encouraged to transition to successor projects like Ringdove EDA, which builds on similar principles but continues active development.[2] Despite its discontinued status, gEDA's tools remain available for download and use, contributing to the legacy of accessible EDA software.[3]Overview
Project Goals and Scope
gEDA is a GPL-licensed suite of Electronic Design Automation (EDA) tools designed to support schematic capture, simulation, and printed circuit board (PCB) layout, serving as a free alternative to proprietary software for hobbyists, educators, and professionals in electronics design.[4][5] The project aims to provide vendor-independent, fully featured tools that enable an open design flow, ensuring accessibility and protection for legacy designs through open-source principles.[4] Originating in the UNIX/Linux environment, gEDA was initiated in 1998 to address the scarcity of free EDA software available at the time, particularly for Linux users lacking robust options for circuit design.[5] A core goal has been to foster modularity and interoperability among its components, allowing users to integrate tools flexibly in scriptable workflows that promote collaboration and customization.[4][6] The scope of gEDA is centered on electronic circuit design, encompassing front-end tasks like schematic development and netlisting, as well as back-end processes such as PCB production preparation, but it does not extend to comprehensive integrated circuit (IC) design or advanced field-programmable gate array (FPGA) synthesis.[5][6] This focus makes it suitable for low- to mid-level projects, emphasizing collaborative and scriptable approaches over high-end semiconductor fabrication tools.[4]Licensing and Development Philosophy
gEDA employs the GNU General Public License (GPL) version 2 or later for all its software components, including core tools like gschem and gnetlist, as well as libraries and utilities.[7] This copyleft license guarantees users the freedoms to freely redistribute, modify, study, and access the source code, which aligns with the project's commitment to open-source principles in electronic design automation (EDA).[7] By mandating that derivative works also be licensed under GPL, it promotes a collaborative ecosystem where developers can contribute enhancements, bug fixes, and new features back to the community, thereby sustaining the project's evolution through voluntary participation rather than commercial incentives.[7] The development philosophy of gEDA emphasizes a federated approach, structuring it as a loose collection of interoperable tools rather than a tightly integrated monolithic suite.[8] This modularity, exemplified by independent programs such as gschem for schematic capture, gnetlist for netlisting, and gattrib for attribute management, allows developers to maintain and evolve individual components autonomously while ensuring they work together seamlessly.[8] Interoperability is achieved through command-line interfaces, shell scripts, and Unix pipes, enabling users to chain tools in custom workflows—for instance, piping schematic data from gschem directly into gnetlist for processing—without relying on proprietary APIs or graphical integrations.[8] This Unix-centric ethos prioritizes flexibility, portability, and scriptability, distinguishing gEDA from commercial EDA tools that often lock users into closed ecosystems. Central to this philosophy is the use of human-readable, text-based file formats, such as .sch for schematics and .sym for symbols, which reject proprietary binary formats in favor of plain ASCII text.[9] These formats facilitate version control with tools like Git, automate processing via scripts, and enhance portability across systems, as files can be edited directly with any text editor.[9] By design, this approach supports the project's goal of accessibility for Unix-like environments, empowering users to integrate gEDA into broader automation pipelines while maintaining transparency and ease of debugging.[9]History
Founding and Early Development
The gEDA project was founded by Ales Hvezda on April 1, 1998, in response to the notable absence of free electronic design automation (EDA) software available for Linux and UNIX systems at the time.[10] Hvezda, a software developer interested in open-source hardware, initiated the effort to create an accessible toolkit that would enable hobbyists and engineers to perform circuit design without relying on proprietary tools.[11] This launch aligned with the broader goals of developing a GPL-licensed suite for electronic design, emphasizing community-driven innovation in PCB workflows.[4] Shortly after its inception, gEDA released its first core components: gschem, a schematic capture tool for creating and editing circuit diagrams, and a basic netlister (gnetlist) to generate connectivity data from schematics.[10] These tools formed the foundation of the project, allowing users to document designs in a standardized format while supporting export to various simulation and layout environments.[11] By focusing on simplicity and interoperability, the initial releases addressed fundamental needs in open-source EDA, such as attribute management and file compatibility.[4] In late 1998, the project integrated the PCB layout tool, originally developed separately by Thomas Nau and maintained by Harry Eaton, to provide end-to-end support for printed circuit board design.[5] This addition, facilitated through scripts like gsch2pcb for forward annotation from schematics to layouts, marked a significant expansion beyond initial schematic-focused efforts.[4] Early development faced challenges in bootstrapping a comprehensive suite from scratch, relying entirely on volunteer contributions from unpaid hobbyists, professional electrical engineers, and software developers who addressed basic circuit design requirements for educational and personal projects.[4] The volunteer-driven model emphasized practical utility for students and robotics enthusiasts, fostering gradual improvements through mailing lists and shared code repositories.[11]Key Milestones and Evolution
The gEDA project marked key progress in the mid-2000s with the integration of its core tools into a cohesive suite, enabling seamless workflow from schematic capture to PCB layout. By 2005, enhancements to gnetlist improved netlist generation and backend support for various EDA formats, allowing better interoperability with external tools like PCB layout software.[5] Around 2004–2007, gEDA expanded to include simulation interfaces, with support for SPICE-based circuit simulation integrated through gschem and gnetlist, facilitating netlist export to simulators such as NG-SPICE for analog and mixed-signal analysis.[12] This addition, refined through community contributions in the late 2000s, supported more comprehensive design verification without proprietary dependencies.[13] Through the late 2000s and into the 2010s, gEDA evolved via ongoing community-driven improvements, achieving consistent release cycles up to version 1.8 in 2013.[14] Adoption grew in educational settings and open hardware initiatives, where its GPL licensing and modular design appealed to hobbyists and academic projects focused on accessible EDA tools.[15] Development momentum waned in the 2010s. Releases continued sporadically, with gschem reaching version 1.10.1 in December 2020, but commit activity dwindled, reflecting resource constraints in the volunteer-driven project. By the early 2020s, active maintenance ceased, culminating in the project's official archival in June 2025, with repositories marked read-only and users directed to successor efforts.[16][17]Core Tools and Components
Schematic Capture and Editing
gschem serves as the primary tool within the gEDA suite for schematic capture and editing, enabling users to create detailed electronic circuit diagrams through a graphical interface. It facilitates the input of components, connections, and annotations in a manner optimized for both visual design and data processing, supporting the creation of schematics that can represent complex systems without delving into physical layout details.[18] At its core, gschem supports hierarchical schematic entry, allowing designs to be organized across multiple sheets for modularity and scalability. Users can incorporate sub-sheets using special symbols with asource= attribute to reference external schematic files, enabling navigation between hierarchy levels via the Hierarchy menu or page manager tools like page-up and page-down keys. This multi-sheet capability is exemplified in sample projects such as the gTAG schematic, where top-level symbols link to detailed sub-components. Symbols in gschem are managed as light (minimal attributes) or heavy (with embedded attributes like footprints) entities, placed from libraries configured in the gafrc file, such as (component-library "./symbols"). Wires and nets are drawn by clicking and dragging with the left mouse button, with options to toggle net dragging using the "o" key followed by "r" to avoid unintended connections during component movement. Pins connect these elements, and zero-length pins can be defined by setting identical coordinates, as in P 100 100 100 100 1 0 0, for compact symbol designs. Attributes, including labels and values, are editable directly on objects, with invisible ones promotable via (promote-invisible "enabled") in the gafrc configuration. Bus routing provides a visual representation for grouped signals, though it functions decoratively; actual connections rely on netname= attributes like net=busA:1, without direct support for bus-to-subsheet linkages in standard workflows.[18]
Editing capabilities in gschem emphasize flexibility in symbol and attribute management to streamline iterative design. Symbol libraries are sourced from default installations or external repositories like gedasymbols.org, where users can download or contribute symbols tailored for specific components, ensuring broad compatibility across projects. Attribute editing occurs through the Edit → Edit Text menu or the companion tool gattrib for bulk operations, supporting features like overlining text with \_text\_ for emphasis in documentation. For output, gschem exports schematics to formats such as PostScript or PNG via the gaf export command, for instance gaf export -o MY_SCH.pdf MY_SCH.sch, with color rendering enabled through (print-color "enabled") in the gschemrc file, aiding in professional documentation and sharing.[18][19]
In terms of workflow integration, gschem schematics are stored in human-readable .sch files, which serve as the direct input for subsequent netlisting processes in the gEDA pipeline. These ASCII-based files, detailed in the gEDA file format specification, use a structured syntax with single-letter object identifiers (e.g., T for text, U for components) and space-separated fields for coordinates in mils, making them fully text-editable with standard tools. This format inherently supports scripting via Guile Scheme, gEDA's embedded extension language, where procedures like schematic-file→page allow programmatic manipulation of schematics—such as editing attributes, copying objects, or automating rotations—directly from .sch files. The plain-text nature also facilitates seamless integration with version control systems like Git, as changes are diffable and mergeable without binary conflicts, promoting collaborative development. Scripts can be loaded from the ~/.gEDA directory via gschemrc for customized automation in design workflows.[9][20]
Netlisting and Attribute Management
In gEDA, netlisting involves extracting electrical connectivity information from schematic files generated by gschem, transforming graphical representations into structured data suitable for downstream processes such as PCB layout or circuit simulation.[21] This process creates a netlist, which serves as a connectivity matrix defining nodes and connections between component pins, enabling tools to interpret the circuit's topology without relying on visual elements.[21] The primary tool for this is gnetlist, a command-line utility that compiles one or more schematic files into an in-memory representation before exporting it via customizable backends.[21] gnetlist supports a wide array of output formats, including SPICE for simulation, VRML for 3D visualization, and PCB-specific netlists for layout tools like the gEDA PCB program, with over 25 backend options available.[21] Users can select backends via the-g option, such as -g spice-sdb for SPICE netlists or -g pcbpins for pin-based PCB inputs, and extend functionality through Scheme scripts for custom outputs.[21] Additionally, gnetlist incorporates basic electrical rule checking (ERC) through its drc2 backend, which detects issues like unconnected pins or duplicate references to ensure schematic integrity before netlist generation.[22] This ERC can be configured or disabled via a Scheme-based rules file, allowing users to tailor checks for specific design needs, such as ignoring unconnected pins with the directive (define dont-check-unconnected-pins 1).[22]
Attribute management in gEDA complements netlisting by facilitating the organization and editing of component properties that influence connectivity and output accuracy. The tool gattrib provides a spreadsheet-like interface for bulk editing attributes across multiple schematics, displaying components as rows and attributes as columns for efficient modification.[23] Key attributes handled include value for component specifications (e.g., value=1K for a resistor), refdes for unique references (e.g., refdes=R1), and footprint for PCB package assignments (e.g., footprint=DIP14), all of which are critical for accurate netlist generation and downstream processing.[24] Other netlisting-relevant attributes encompass device for symbol identification, pinnumber and pinseq for pin ordering, and pintype for electrical characteristics like input or output, ensuring the netlist reflects precise pin-to-node mappings.[24]
To maintain symbol integrity, gsymcheck validates component symbols used in schematics, performing checks on attributes and structure that indirectly support robust netlisting and attribute management.[25] It verifies essentials like the presence of device=, footprint=, and pin-related attributes (pinlabel=, pintype=, pinseq=), detects duplicates or invalid values, ensures pins align on a 100-unit grid, and flags issues such as unconnected elements within symbols or obsolete attributes.[25] By running gsymcheck on symbol files (e.g., gsymcheck -v my_symbol.sym), users can preempt errors that might propagate to netlists, such as mismatched pin counts or syntax flaws.[25] This validation step is particularly valuable for library maintenance, as it enforces consistency in attributes that gnetlist and gattrib rely upon for connectivity extraction and editing.[25]
PCB Layout and Routing
The PCB tool, also known as gpcb in the gEDA suite, serves as the primary application for printed circuit board layout and routing, enabling users to create interactive designs on Unix-like systems, Windows, and macOS. It supports multi-layer boards up to 16 copper layers, allowing for complex topologies such as signal, power, and ground planes, with customizable layer groups for copper, silkscreen, solder mask, and documentation purposes. Footprint placement is handled through an extensive library system, where users manually or semi-automatically position components like resistors, capacitors, and integrated circuits, visualizing connectivity via ratlines that represent unconnected nets in a "rats nest" display to guide the design process.[26][27][28] Routing in PCB combines manual and automated approaches to establish electrical connections between footprints. Manual routing uses tools like the line selector for precise trace drawing, supporting vias for layer transitions and adjustable widths to meet impedance requirements, while an integrated autorouter optimizes paths by selecting from multiple algorithms to minimize length and avoid obstacles. The tool includes a design rule checker (DRC) that enforces clearances, trace widths, via sizes, and pad spacing—configurable to standards like 0.15 mm minimums—flagging violations in real-time during editing to prevent manufacturing errors. It accommodates both surface-mount devices (SMD), such as 0402 packages, and through-hole components, with features like pin swapping and element alignment aids to refine layouts iteratively.[29][27] The workflow integrates seamlessly with upstream gEDA tools by importing netlists generated via gsch2pcb, which automates footprint matching based on schematic attributes and performs initial component placement, such as dispersing elements across the board canvas. Once imported, users refine the layout, route traces, and run DRC before exporting outputs essential for fabrication, including RS-274X Gerber files for photoplotting, Excellon drill files for vias and holes, and bill-of-materials (BOM) in CSV or text formats for assembly. This process ensures traceability from schematic to physical board, with additional support for photorealistic renders and centroid data for pick-and-place machines.[30][29]Supporting Utilities
gsch2pcb serves as a key utility in the gEDA suite, automating the generation of PCB projects from schematic files created with gschem by processing netlists via gnetlist to produce footprint assignments, element lists, and board outlines compatible with the PCB layout tool.[31] It operates from the command line, with options for verbose output to aid in debugging footprint mismatches, and allows customization of the layer stack through editing the underlying Scheme script gnet-gsch2pcb.scm.[31] This tool streamlines the transition from schematic design to physical layout without manual intervention, ensuring consistency in attribute handling such as part values and references.[30] Complementing gsch2pcb, xgsch2pcb provides a graphical user interface built on GTK, enabling intuitive selection and management of schematic files for netlisting and PCB project creation, which is particularly useful for users preferring visual workflows over command-line operations.[32] It integrates directly with gschem outputs, facilitating updates to existing PCB projects as schematics evolve, and supports batch processing of multiple schematics in a project directory.[33] For simulation verification, gEDA relies on netlist exports from gnetlist rather than a built-in simulator, with the spice-sdb backend generating compatible formats for external tools like ngspice, an open-source SPICE analog simulator, allowing users to perform transient, AC, and DC analyses on circuit designs.[13][34] Digital simulation is supported through scripts interfacing with Icarus Verilog for Verilog-based verification or GHDL for VHDL, though these require manual netlist adaptation.[13] Waveform analysis of simulation outputs is handled by gwave, a GTK-based viewer that loads raw files from ngspice or gnucap, supporting multiple panels, variable traces, and cursor-based measurements for time and voltage differences.[35] Additional utilities include file format converters such as translate2geda, which enables import and export between gEDA formats and those of Eagle or KiCad, facilitating interoperability for users migrating designs across EDA tools.[36] For library management, batch processing is achieved via Guile scripting in libgeda, allowing automated symbol and footprint validation, duplication checks, and organization across directories without graphical intervention. These tools collectively enhance workflow efficiency by handling auxiliary tasks like data export and repetitive maintenance.[37]Platform Support
Unix-like Systems
gEDA offers full native compatibility on Unix-like systems, serving as its primary development and deployment environment. However, due to the project's archival status as of the early 2020s, binary packages are no longer available in many recent Linux distributions. On older versions of Debian (prior to approximately 2020), users could install the suite via the Advanced Package Tool (APT) by enabling relevant repositories and running commands likesudo apt-get install geda. As of 2025, gEDA packages have been removed from current Debian repositories, requiring users to build from archived source tarballs or use third-party archives.[38] Similarly, for older Fedora and Red Hat-based systems, RPM packages were available through Fedora Extras or third-party repositories, installable with YUM or DNF, such as sudo yum install geda-gaf. These are no longer maintained in official repositories as of 2025, with users advised to compile from source.[39]
For BSD variants, gEDA remains supported through ports collections, allowing compilation and installation tailored to the operating system. On FreeBSD, the suite is available in the ports tree under the cad/geda category, where users can build it with make install clean after fetching the port (version 1.8.2 as of 2025).[40] OpenBSD provides a meta-port for gEDA in its ports system (version 0.1p1), facilitating installation via pkg_add geda or building from source in /usr/ports/meta/geda.[41] These ports ensure compatibility with the respective BSD kernels and libraries, though the software versions are outdated.
When packages are unavailable or customization is needed, gEDA can be built from source using the GNU autotools build system, which is standard for Unix-like environments. The process involves downloading the source tarball from project archives, running ./configure to detect dependencies like GTK+ and X11, followed by make and sudo make install.[16] X11 is required for the graphical interface, while GTK+ provides the widget toolkit; these must be installed beforehand, often via package managers (e.g., sudo apt install libgtk2.0-dev libx11-dev on Debian). Users should verify compatibility with current library versions, as gEDA relies on older dependencies like GTK+ 2, which may require additional configuration on modern systems.
gEDA achieves optimal performance on Unix-like systems due to its design as a collection of modular, command-line tools that integrate natively with POSIX environments. This enables efficient scripting via Guile Scheme for automation and seamless incorporation into shell pipelines, makefiles, or other Unix workflows, such as chaining netlisting outputs directly to PCB routing processes.[20]
macOS
gEDA, leveraging its Unix-like foundations, adapts to macOS through its Darwin-based environment, enabling installation and operation via specialized package managers that handle dependencies such as GTK+ for the graphical interface.[42] Installation on macOS primarily occurs via MacPorts or Fink, which resolve key dependencies including GTK+ for cross-platform GUI support, often utilizing X11 rather than native Quartz for rendering. With MacPorts, users executesudo port install geda-gaf to obtain the full suite (version 1.10.2 as of last update), alongside separate installation for the PCB tool, ensuring dependency management through ports like guile and gtk2.[43] Fink provides fink install geda-bundle for binaries prepared for macOS compatibility. Homebrew offers support for individual components, such as the PCB editor, though full suite compilation may require additional troubleshooting for recent macOS versions.[44] As of 2025, installations via MacPorts continue to be reported, indicating functionality on macOS 15 and later with XQuartz.[45]
gEDA demonstrates strong compatibility on Intel-based macOS systems and extends to Apple Silicon architectures through Rosetta 2 emulation, facilitating seamless execution of its Intel-compiled binaries without native ARM builds. However, integration with macOS's native Aqua interface can present challenges, particularly for GTK+-based tools, leading to recommendations for installing XQuartz to enable full X11 GUI functionality and avoid rendering issues. The suite operates on versions beyond macOS 10.15 Catalina, with users advised to check for dependency updates.[42]
In usage, gEDA on macOS mirrors its Unix-like behavior, with minor adjustments such as setting environment variables like LTDL_LIBRARY_PATH=/opt/local/lib for MacPorts-installed libraries to ensure proper loading of components like Guile. Path configurations in shell profiles, such as .bash_profile, help manage distinctions between package managers (e.g., /sw for Fink, /opt for MacPorts), promoting reliable schematic capture and PCB workflows.[46]