# Qucs-S Circuit Simulation with Qt6 and Multiple Kernels

> Qucs-S is a Qt6 desktop application for schematic capture, circuit visualization, and simulation through Ngspice, Xyce, SpiceOpus, or Qucsator. It suits engineers who want a graphical workspace around SPICE-compatible engines, but compilation requires several native dependencies and ngspice must be installed separately.

**ra3xdh/qucs_s** — Qucs-S is a circuit simulation program with Qt-based GUI

- Repository: https://github.com/ra3xdh/qucs_s
- Website: https://ra3xdh.github.io/
- Stars: 1,415 · Forks: 176
- Language: C++
- License: GPL-2.0
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/ra3xdh-qucs-s

## Qucs-S and Its Simulation Kernels

Qucs-S addresses the gap between drawing a circuit in a desktop schematic editor and sending that design to a separate SPICE engine. It gives engineers a graphical user interface for schematic capture and result visualization while leaving numerical simulation to one of four supported kernels: Ngspice, Xyce, SpiceOpus, or Qucsator. The README marks Ngspice as the recommended choice. Qucsator is identified separately as non-SPICE, which matters when a project depends on SPICE model syntax or an engine-specific workflow.

The intended users are electronics engineers, students, and developers who already understand circuit models or SPICE conventions but want a graphical workspace for creating and inspecting simulations. The repository also contains example directories for Ngspice, Xyce, Qucsator, postprocessing, symbols, templates, and an external interface. Those directories indicate that Qucs-S supports more than one kind of simulation project, although the README does not provide a full catalog of every example or model format.

Qucs-S is based on the original Qucs codebase. Its current identity is therefore broader than a single SPICE implementation: it combines a Qt6 desktop interface with external simulation engines and a library of passive and active components.

## How Qucs-S Moves a Design Through the Simulation Stack

The documented architecture has three visible parts. First, Qucs-S provides schematic capture so a circuit can be entered graphically. Second, it provides visualization and postprocessing tools for examining simulation output. Third, it connects that work to an installed simulation kernel rather than treating every numerical engine as part of the GUI itself.

This separation gives the application a practical choice of back ends. A user can select among Ngspice, Xyce, SpiceOpus, and Qucsator according to the engine available in the environment or the model compatibility required by the design. The README specifically says ngspice is not needed while compiling Qucs-S, but it is required at runtime to run the simulation. That distinction affects both build systems and deployment planning.

The repository layout reinforces this structure. Directories such as `examples/ngspice/`, `examples/xyce/`, and `examples/qucsator/` correspond to different engine-oriented workflows. Other directories include `qucs-activefilter/`, `qucs-attenuator/`, `qucs-filter/`, and `qucs-powercombining/`, while `library/` represents the component side of the application. The README does not document the internal conversion format or explain how every engine-specific netlist option is passed, so the exact data path between schematic and kernel should be checked in project-specific configuration.

## Installing Qucs-S on Ubuntu or Debian

The README provides package-manager commands for Ubuntu and Debian. The first command installs ngspice, the C++ build toolchain, CMake, parser-generator tools, and dos2unix. The second and third commands install Qt6 development packages and related libraries. These are source-build dependencies, not instructions for installing a packaged Qucs-S binary.

On Ubuntu or Debian, the documented commands are:

```bash
sudo apt-get install ngspice build-essential git cmake flex bison gperf dos2unix
```

The command installs ngspice for runtime simulation and the tools needed to compile the application. A second command adds the Qt6 base, tools, SVG, language, and development packages:

```bash
sudo apt-get install qt6-base-dev qt6-tools-dev qt6-tools-dev-tools libglx-dev linguist-qt6
```

The README lists a third command for additional Qt6 and OpenGL development packages:

```bash
sudo apt-get install qt6-l10n-tools libqt6svg6-dev libgl1-mesa-dev libqt6opengl6-dev
```

The project also documents Linux, Windows, FreeBSD, and macOS support. It directs users to its Installation wiki for binary installation instructions, so the commands above should not be treated as the recommended path for every platform.

## Building Qucs-S with CMake

The source build begins by initializing the repository's Git submodules. The README then creates a separate `builddir`, runs CMake from that directory, compiles with make, and installs the result. The installation prefix is explicit in the documented command, which is useful when `/usr/local` is not appropriate.

From the repository's top directory, the documented build sequence is:

```bash
git submodule init
git submodule update
mkdir builddir
cd builddir
cmake ..  -DCMAKE_INSTALL_PREFIX=/your_install_prefix/
make
make install
```

The two Git commands prepare submodules before CMake is invoked. CMake then generates the build configuration, `make` compiles it, and `make install` places the installed files under the selected prefix. The README says the default installation directory is `/usr/local` when `CMAKE_INSTALL_PREFIX` is not defined.

Qt6 has been the default since version 25.1.0. The README states that Qt5 support was dropped in that version, so an older project configuration based on Qt5 needs review before it is used with a current Qucs-S release. It also says to set `WITH_QT6=ON` when compiling versions before v25.1.0.

## Launching Qucs-S and Configuring Clangd

After installation, the README instructs users to launch the `qucs-s` executable. The launch command is shown from the installation prefix's `bin` directory:

```bash
cd /your_installation prefix/bin
./qucs-s
```

The README contains a space in `/your_installation prefix`, so that path is not a valid shell path as written unless the surrounding directory name actually contains a space. A user should substitute the real installation prefix rather than copying the placeholder literally. This launch step starts the graphical application. It does not install a simulation kernel, so ngspice still needs to be available at runtime if it is the selected kernel.

The project also documents Clangd Language Server support. Clangd searches parent directories for `compile_commands.json`. The README says CMake generates this file along with other build configuration files, and it gives a separate setup for linking an existing file into the project root:

```bash
mkdir builddir
cd builddir
cmake ..  -DCMAKE_INSTALL_PREFIX=/your_install_prefix/
```

If `compile_commands.json` already exists in the build directory, the documented root-level link is:

```bash
cd project_root
ln -s ./builddir/compile_commands.json compile_commands.json
```

The `.clangd` file holds the project's Clangd configuration. The README warns that initial indexing can take time, but it does not document a guaranteed indexing duration.

## Qucs-S Limitations and Engine Compatibility

The clearest limitation is dependency management. Qucs-S is not described as a standalone simulator with its numerical engine embedded in the binary. Ngspice is recommended, but it must be installed separately for runtime use. An installation that starts successfully can therefore still be unable to run simulations if the selected engine is missing or incompatible with the circuit's models.

A second limitation is the Qt version boundary. Current Qucs-S versions use Qt6, while Qt5 support was dropped in v25.1.0 according to the README. This reduces the need to maintain two Qt paths, but it also makes the application's build requirements less flexible for systems that still standardize on Qt5. The documented build dependencies include QtCharts, CMake, flex, bison, gperf, dos2unix, and development packages beyond the core Qt6 libraries.

The engine choice is also a compatibility decision. Qucs-S supports several kernels, but the README does not claim that all four implement identical models, directives, analyses, or postprocessing features. It does not provide a model compatibility matrix. For a design that depends on a particular SPICE implementation or proprietary model syntax, the selected engine and its documentation must be checked before migration.

The project is also a desktop application rather than a documented headless automation interface. The repository contains an `examples/external_interface/` directory, but the README does not describe how that interface is invoked or whether it supports unattended batch simulation. Engineers needing a command-line-only workflow should not assume that the graphical application provides one.

## Qucs-S License, Releases, and Maintenance

Qucs-S is distributed under the GPL-2.0 license according to the repository metadata, and the repository includes a `COPYING` file. That identifies the project's licensing model, but it does not answer whether a particular distribution, linked library, or modified deployment satisfies every applicable obligation. Those questions require a separate review of the license and the distribution being assembled.

The repository is not archived. Its last push was on 2026-10-10, and the release list includes `continuous_build` on 2026-10-10, version 26.1.1 on 2026-04-26, and version 26.1.0 on 2026-04-09. The date of the last push is the relevant maintenance fact available here. The README does not describe a long-term support policy, upgrade migration script, compatibility guarantee, or release cadence beyond the named releases and continuous-build entry.

The main upgrade cost is environmental. Moving to a current build requires accepting the Qt6 requirement, updating the native toolchain, and checking that the chosen simulation kernel remains available. Source builds also require submodules and the listed build utilities. Binary users have a different path because the README directs them to a platform Installation wiki, but the repository does not provide one universal binary command.

## Conclusion

Qucs-S is appropriate for engineers who need graphical schematic capture and a choice of SPICE-oriented simulation kernels, particularly on systems where they can install Qt6 and the selected engine. It is less suitable for users who need Qt5 support, a self-contained binary whose simulation dependencies are already managed, or a command-line-only workflow. Verify the platform package or wiki installation instructions first, then confirm that the required kernel, especially ngspice, is installed separately. On source builds, also verify the Qt6 and CMake build dependencies before deciding whether to adopt the project.

## FAQ

### Which simulation engine should I use with Qucs-S?

The README marks Ngspice as the recommended simulation engine. Qucs-S also supports Xyce, SpiceOpus, and Qucsator, but the documentation does not provide a feature-by-feature comparison of those engines.

### Does Qucs-S require Qt5 or Qt6?

Current Qucs-S versions use Qt6. The README says Qt5 support was dropped in v25.1.0 and that `WITH_QT6=ON` applies to versions before that release.

### Do I need ngspice to build or run Qucs-S?

The README says ngspice is not required at compile time, but it is required as a runtime dependency to run the simulation. It should therefore be installed separately before using ngspice as the simulation kernel.

## Sources

- [License: GPL-2.0](https://github.com/ra3xdh/qucs_s/blob/current/LICENSE)
- [Project website](https://ra3xdh.github.io/)
- [ra3xdh/qucs_s on GitHub](https://github.com/ra3xdh/qucs_s)
- [README](https://github.com/ra3xdh/qucs_s/blob/current/README.md)
- [Releases](https://github.com/ra3xdh/qucs_s/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/ra3xdh-qucs-s