# Ducky bundles two dozen network utilities into one PySide6 window

> Ducky is a Python and PySide6 desktop application that puts a terminal, port scanner, DNS and Whois lookups, a topology mapper, TLS inspection and a set of security utilities behind a single interface with light and dark themes. It is built for students and network engineers who want one program instead of a folder of command line tools.

**thecmdguy/Ducky** — Ducky is a powerful, open-source, all-in-one desktop application built with Python and PySide6. It is designed to be the perfect companion for network engineers, students, and tech enthusiasts, combining several essential utilities into a single, intuitive graphical interface. We welcome contributions from the community!

- Repository: https://github.com/thecmdguy/Ducky
- Stars: 909 · Forks: 80
- Language: Python
- License: MIT
- Published: 2026-10-20 · Updated: 2026-10-20 · Language: en
- Canonical page: https://hysenlabs.com/projects/thecmdguy-ducky

## One window instead of a folder of scripts

Ducky is described as a powerful desktop application that combines essential networking, security and diagnostic utilities into a single, intuitive graphical interface with customizable themes. The project description puts the audience plainly: it is designed to be the perfect companion for network engineers, students, and tech enthusiasts, combining several essential utilities into a single, intuitive graphical interface.

That framing tells you what it is and is not. This is a GUI front end to the standard diagnostic repertoire, not a scanner framework and not a toolkit of novel techniques. The pitch in the README is direct about the motivation: stop switching between dozens of tools and get everything you need in one place.

The tool count is roughly two dozen, and the tables in the README group them into categories. The Terminal section has one entry, a Multi-Protocol Terminal that connects via SSH, Telnet and Serial, in a tabbed interface with session save and load. Network Diagnostics has six: a Network Monitor for live CPU, memory and network I/O stats on the local machine, Ping, Traceroute, a multi-threaded TCP Port Scanner with custom port range support, a Subnet Calculator that computes network address, broadcast and usable host range from any CIDR, and Wake-on-LAN for booting remote machines by MAC address.

DNS and Email has five. Network and IP has five more, including a Topology Map that auto-discovers your network with ICMP plus SNMP and renders a live graphical device map, and a Device Scan that lists active hosts on your LAN with IP, MAC and hostname.

Then Website Analysis, Security and Utilities. The Security group is the one that gives the app its character: a Blacklist Check against 10 DNSBL spam blacklist servers simultaneously, a CVE Scan that searches the NIST NVD by product keyword, a Password Checker with estimated crack time and improvement tips, and a Hash Tool for MD5, SHA1, SHA256 and SHA512 that also includes a dictionary cracker.

The through-line is a working network engineer's day, gathered into one place.

## The install is a venv, an editable install and one command

The prerequisites are Python 3.8 or newer with 64-bit recommended, plus pip and venv, which the README notes are included with modern Python.

You clone the repository first.

```bash
git clone https://github.com/thecmdguy/Ducky.git
cd Ducky
```

Then you create a virtual environment and install the dependencies. On Windows that is:

```bash
python -m venv venv
.\venv\Scripts\activate
pip install -e .
```

And on macOS and Linux:

```bash
python3 -m venv venv
source venv/bin/activate
pip install -e .
```

The editable install is the right choice here because the application lives in src/ducky_app, and an editable install means you can change the code and rerun without reinstalling.

Running it differs by platform only in how you reach the interpreter in the virtual environment. On Windows:

```bash
.\venv\Scripts\python.exe src\ducky_app\main.py
```

On macOS and Linux:

```bash
python src/ducky_app/main.py
```

The manifest also registers a console script, ducky = ducky_app.main:run, so after the editable install the command is available without pointing at the file path. That entry point is the more convenient form of the same thing.

Two notes in the README will save you a support question. The first is the libpcap warning. On first run you may see WARNING: No libpcap provider available!, which is a harmless Scapy message that can be safely ignored, and the README says Ducky works perfectly without it. The second is about privileges, which is the more important of the two. Topology Map and Device Scan use raw ICMP packets and require administrator or root privileges to scan the network.

That second note is a design consequence rather than an oversight. Raw sockets are how you get a device scan to work without installing an agent on every host, and they are gated by the operating system for good reason. So on Linux, those two features of a desktop app simply do not work without elevating the whole application.

## The dependency pins are exact and old

The dependency list in pyproject.toml is worth reading closely, because every version is pinned exactly.

```toml
dependencies = [
    "PySide6==6.6.0",
    "pyserial==3.5",
    "psutil==5.9.5",
    "scapy==2.5.0",
    "requests==2.31.0",
    "zxcvbn==4.4.28",
    "paramiko==3.3.1",
    "telnetlib3==2.0.1",
    "pysnmp==4.4.12"
]
```

Each dependency maps to a feature, which is a quick way to understand the implementation. PySide6 is the Qt for Python binding that provides the whole interface. pyserial gives the Serial connection in the terminal. psutil supplies the live CPU, memory and network I/O numbers in the Network Monitor. scapy is the packet library behind the topology mapper and device scan, and also behind the libpcap warning. requests is the HTTP client for the HTTP Headers tool and the DNS lookups. zxcvbn is the password strength estimator behind the Password Checker, which is why that tool reports an estimated crack time rather than a made up score. paramiko is the SSH library, and telnetlib3 is the Telnet one. pysnmp is the SNMP library used by the topology discovery.

The pinning is exact rather than a lower bound, and the versions are not current. That is a deliberate-looking choice for a desktop application where a broken transitive dependency breaks the whole application, but it has a cost: on a modern Python, some of these older pins may not install cleanly.

The metadata also shows signs of a project still being set up. The version field reads 1.3.0 while the released version is 1.5.0 and the README badge says Version 1.5, and the authors field is still the placeholder Your Name with youremail@example.com. The build system is setuptools with setuptools>=61.0, and the package layout is handled with a packages list of ducky_app and a package-dir mapping of the empty string to src.

## The Windows installer script does the packaging work for you

Building an installer is a single PowerShell script, run from the Ducky folder.

```bash
.\build_installer.ps1
```

The README lists what it does automatically, and the list is a good map of how the project is packaged. It verifies the virtual environment. It installs PyInstaller and Pillow if missing. It converts the PNG icon to a multi-resolution .ico. It bundles the app with PyInstaller into dist\Ducky\. It installs Inno Setup 6 via winget if not found. And it compiles the installer to installer\Ducky-Setup-1.5.0.exe.

The repository listing shows the artefacts that script works with. There is build_installer.ps1 at the root, a ducky.spec file which is the PyInstaller specification, and an installer.iss file, which is the Inno Setup script that produces the final executable.

The two-stage approach is standard for Windows application distribution and it is worth understanding what each stage buys you. PyInstaller produces a folder containing the interpreter and every dependency, which is portable but is not an installer. Inno Setup wraps that folder into a single .exe with a wizard, a Start menu entry and an uninstaller. Users get one file.

The install scripts on Windows are the reason a Windows build exists at all, and it is the platform the project seems to target first. The README's build script runs in PowerShell, the winget dependency is Windows specific, and the release artefact name carries a .exe.

The customization section is small but tells you the app is meant to be lived in. Themes are switched between dark and light via Settings then Preferences. Terminal sessions have their own font family, size and colours, configured per session rather than globally. And sessions can be saved and reloaded from the left panel, which is the feature that turns a terminal tab into something you come back to.

## Where Ducky is the wrong tool

Four cases rule it out, and the first is about where the tool can run.

A server with no desktop is out. This is a PySide6 desktop application with a GUI. It needs a display, a Python environment and the pinned dependency set. If your work happens over SSH on a headless box, or on a machine where installing a Qt stack is not acceptable, then a set of command line tools is the right answer, and Ducky is a wrapper for exactly those.

The second is restricted privilege environments. Topology Map and Device Scan need raw ICMP packets and therefore administrator or root. Where a user cannot elevate, two of the most visually impressive features of the application simply do not work, and you cannot run the app as administrator to get them because giving the whole GUI admin rights is its own problem.

The third is a network you are not authorised to scan. The Port Scanner, Device Scan, Topology Map and DNS Propagation tools all send traffic to hosts other than your own machine. On your own LAN, that is routine administration. Against someone else's network, that is unauthorised traffic, and the tool's existence does not make it permitted. The same applies to the CVE Scan, Blacklist Check and Whois tools, which send queries to external services on your behalf.

The fourth is reproducibility of the environment. Exact version pins across nine dependencies, including a 2023-era PySide6 and a psutil from before the current major series, means the application is pinned to the Python versions those wheels support. On a machine with a newer Python, pip may refuse to resolve the set at all, and the README does not document a supported version matrix beyond the 3.8 or newer floor.

The alternative is the one the project is implicitly built on: the same command line tools, individually. Everything Ducky does has a standard equivalent, and a wrapper adds value when you want the tools side by side rather than as a collection of shell scripts you have to remember the names of. If you already know the commands, the wrapper is mostly a nicer screenshot.

## Conclusion

Adopt Ducky if you are learning networking or doing day to day network work on a desktop and want one window instead of a folder of command line tools, since the diagnostics it groups together are the ones you reach for repeatedly. Do not adopt it if you need a portable tool for a remote host with no Python, or if your environment blocks the raw sockets its topology mapper needs. Before you install, read the privilege note, because Topology Map and Device Scan require administrator or root rights, and confirm the pinned dependency versions still install on your Python, since the manifest pins them exactly.

## FAQ

### How do I install and run Ducky?

Clone the repository, create a virtual environment, activate it and run pip install -e ., then start the app with python src/ducky_app/main.py on macOS and Linux or .\venv\Scripts\python.exe src\ducky_app\main.py on Windows.

### Which Ducky tools need administrator or root privileges?

Topology Map and Device Scan. The README states they use raw ICMP packets and require administrator or root privileges to scan the network.

### What is the WARNING: No libpcap provider available! message?

It is a harmless Scapy message shown on first run, and the README says it can be safely ignored because Ducky works perfectly without it.

### How do I build a Windows installer for Ducky?

Run .\build_installer.ps1 from the Ducky folder in PowerShell. The script verifies the virtual environment, installs PyInstaller and Pillow, converts the icon, bundles the app, installs Inno Setup 6 via winget and compiles installer\Ducky-Setup-1.5.0.exe.

### Which Python libraries does Ducky use?

The manifest pins PySide6 for the interface, pyserial for serial connections, psutil for local system stats, scapy for packet work, requests for HTTP, zxcvbn for password strength, paramiko for SSH, telnetlib3 for Telnet and pysnmp for SNMP.

### Can Ducky switch between light and dark themes?

Yes. The README says themes can be switched between dark and light via Settings then Preferences, and terminal sessions can be customised with their own font family, size and colours.

## Sources

- [Issues](https://github.com/thecmdguy/Ducky/issues)
- [License: MIT](https://github.com/thecmdguy/Ducky/blob/main/LICENSE)
- [README](https://github.com/thecmdguy/Ducky/blob/main/README.md)
- [Releases](https://github.com/thecmdguy/Ducky/releases)
- [thecmdguy/Ducky on GitHub](https://github.com/thecmdguy/Ducky)

---

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