# JQTools packs common Qt developer chores into one desktop and WASM toolbox

> JQTools is a Qt/QML/C++ toolbox for the short text, crypto, image and barcode chores that interrupt a coding session. It ships as a release executable, a qmake project and a browser WASM build, and it is most useful for the developer who keeps pasting snippets into a browser tab.

**188080501/JQTools** — JQTools 是一个基于 Qt/QML/C++ 的开源开发工具箱，集成文本处理、加密计算、图片优化、二维码与 Qt 辅助等常用功能。

- Repository: https://github.com/188080501/JQTools
- Stars: 1,835 · Forks: 523
- Language: C++
- License: MIT
- Published: 2026-10-16 · Updated: 2026-10-16 · Language: en
- Canonical page: https://hysenlabs.com/projects/188080501-jqtools

## The category of task JQTools covers: one value in, one value out

JQTools is not a library you link against. It is a toolbox application aimed at the gap between an editor and a search engine. Every entry in the text section is a single conversion: a string to its UTF-16 escape form, a colour number to `"#112233"`, plain text to URL percent encoding, JSON to a chosen indentation, a line list to ascending or descending order. The calculation section adds digests (SHA1, MD5 for text, MD5, SHA1 and SHA256 for a chosen file), Unix timestamp to date conversion, a binary search over a sorted array, RSA key pair generation in PEM form, RSA encrypt with a public key producing Base64 ciphertext, RSA decrypt from Base64, AES-CBC with PKCS#7 padding and Base64 input and output, and HMAC-SHA256.

That scope tells you who it is for. The user already has a Qt or C++ project open, hits a small chore that needs a precise answer, and does not want to write a throwaway program or open a web page. JQTools answers the chores a developer meets repeatedly during UI work and asset preparation: generating an `icon_128x128@2x.png` from an existing PNG or JPG, converting a ttf icon font to PNG, turning an image into WebP, compressing a PNG losslessly with Zopfli, compressing a JPG lossily with Guetzli, counting lines by counting `'\n'` occurrences, batch replacing a keyword in file names or file contents, and picking a colour off the screen.

The last two Qt specific entries are the clearest signal of the audience. A Q_PROPERTY code generator produces boilerplate from a Q_PROPERTY declaration, and a CPP file generator emits the basic structure of a CPP file. Those are not general utilities; they are scaffolding for a Qt programmer who does not want to retype the same declaration shape every week.

## Where the code lives: qmake subdirs with vendored crypto and imaging libraries

The project is a standard qmake engineering setup with no extra generation or preprocessing step. The top level file is `JQTools.pro`, a subdirs entry point, and the application subproject sits at `apps/JQToolsApp/JQToolsApp.pro`, with the application entry point and core logic under `apps/JQToolsApp/cpp/`. The interface and QML resources live in `qml/`, individual feature modules in `components/`, third party and base library wrappers in `library/`, documentation and the preview image in `doc/`, and icon resources in `icon/`. There are also `fonts/` and `images/` directories at the root.

The interesting architectural decision is that third party code is compiled in rather than linked from the system. Every dependency is referenced from one place, `JQTools.pro` -> `library/JQLibraryImport.pri`, and each module has its own pri file: `library/JQLibrary/JQQRCodeReader.pri` for ZXing based QR and barcode reading, `library/JQLibrary/JQQRCodeWriter.pri` for qrencode based QR generation, `library/JQLibrary/JQZopfli.pri` for Zopfli plus LodePNG, `library/JQLibrary/JQGuetzli.pri` for Guetzli plus Butteraugli, and `library/JQLibrary/JQMbedTLS.pri` for Mbed TLS. Nothing has to be installed separately, but nothing is upgraded by your package manager either.

The README also draws a deliberate line. General capabilities such as digest calculation go through Qt itself, for example `QCryptographicHash`, rather than through a bundled library. Only features that Qt cannot cover, cryptography, QR coding, lossless and lossy image compression, pull in vendored source.

## First run: download the release, or build with qmake

The maintainers call the release route the recommended one. Open the Releases page, download the latest executable, extract it and run it. The link the README points at for this is the latest release URL rather than a fixed version, so the file you get tracks whatever the maintainer last tagged.

Building from source is the route that matters if you want to change the tool. The README lists four verified environments: Qt 5.15.2 with MSVC2019, Qt 6.5.3 with MSVC2019, Qt 5.15.2 with Clang on x86, and Qt 6.8.3 targeting WASM. The Qt Creator path is to open the repository root `JQTools.pro` through `File -> Open File or Project...`, pick a kit, and build after configuring.

The command line path is a short qmake and nmake sequence, run from a fresh build directory on the MSVC toolchain:

```powershell
mkdir build
cd build
qmake ..\JQTools.pro -spec win32-msvc "CONFIG+=release"
nmake
```

The executable normally lands under `build\release\`, though the README is explicit that the actual build directory is what decides. The sample build command is written for MSVC with the `win32-msvc` spec, so adapting it to the Clang or WASM toolchains means changing the spec and the make step yourself; the README does not give those command lines.

## The WASM build is the answer when you cannot install anything

The README lists an online WASM version alongside the desktop executable, hosted at `https://web.jasonserver.com:10035/JQTools/JQTools.html`, and the verified environment list includes Qt 6.8.3 plus WASM, so the browser build is a supported target rather than an experiment.

The repository includes RSA, AES and HMAC features, file hashing, and image compression alongside the online WASM build.

Two limits are worth naming. The URL carries a non standard port and a subdomain that is not obviously the project's own domain, and the repository declares no homepage, so the address is documented in one README line and nowhere else in the tree.

## Image tools are the part with the sharpest edges

PNG warning elimination deserves a close read. The README describes it as a fix for a Qt behaviour: some PNG images load with a console warning, and converting the image through this tool produces a file that no longer warns. 

The icon generator takes the same spirit further. It reads an existing PNG, JPG, JPEG or BMP and emits specific resolutions such as the OSX style `icon_128x128@2x.png`. The icon font to PNG converter works the other way, drawing from a built in ttf font that the README says currently offers 8763 icons. The QR generator and the barcode generator both write PNG files; the barcode generator is restricted, since EAN-13 requires 13 digits starting with 6. A separate QR reader uses ZXing-based code and returns the decoded string.

Compression is split by algorithm, not by format preference. PNG goes through Zopfli and is lossless. JPG goes through Guetzli and is lossy. The README does not document a quality setting, a target size, or any way to preview the difference before overwriting an image.

## Where JQTools is the wrong tool

Several entries are narrower than their names suggest. The line counter counts `'\n'` characters rather than parsing source, so a file with CRLF endings or a final line without a newline gives a number that does not match what an editor reports. The text dedupe and sort tool works at character granularity, not line granularity, which is a different operation from the line sorter sitting next to it. The binary search helper searches an ordered array that you supply, so it will not sort your input first or report a miss with any meaning.

The crypto entries inherit their constraints from Mbed TLS defaults. The README states that RSA key generation offers common key size choices and that AES-CBC uses PKCS#7 padding with Base64 input and output, but it does not name a mode of operation for RSA, an iteration count for PBKDF2, or any key derivation step at all. There is no password based encryption path, so if you need to protect a password you still have to build that yourself.

There is also no scripting surface, no documented command line interface and no plugin API. The README describes features and two ways to run the application, and nothing else. For work that has to run a thousand times inside a pipeline, this is a desktop tool with a browser fallback, not something you point at a file list. And the four verified build environments are all Windows oriented or WASM; the project does not claim a verified Linux or macOS desktop build, which narrows adoption for a Qt developer on either of those.

## Upstream code you inherit when you vendor these libraries

The repository is MIT licensed, with the terms in `LICENSE.txt`. Read that as a statement about JQTools itself. The repository ships source for ZXing, qrencode, Zopfli, LodePNG, Guetzli, Butteraugli and Mbed TLS. Their licensing terms should be reviewed separately from JQTools' top-level MIT licence. This article is not legal advice; the practical point is that a build tree containing five vendored third party codebases has more licence surface than the top level MIT file suggests, and a product that ships JQTools should check each one.

Version history is version dated rather than semver: the releases listed are V26.3.16 on 2026-03-16, V26.3.8 on 2026-03-08 and V26.2.27 on 2026-02-27. Contribution happens on the `develop` branch through pull requests, with issues used for both bug reports and feature requests. The last push to the repository was on 2026-08-16, and the repository is not archived.

## Conclusion

Qt developers who want hashing, RSA or AES, PNG compression and icon generation in one offline place should take the release executable, since every third party library is vendored in source. Anyone who only needs a JSON formatter or a UUID, or anyone on a non Windows toolchain the maintainers have not verified, should look elsewhere. Before adopting, confirm that your platform is covered by the four verified Qt and compiler combinations and read JQLibraryImport.pri to see what gets compiled into your binary.

## FAQ

### Does JQTools need Qt installed to run?

No, not for the release route. You download the latest executable from the Releases page, extract it and run it, with no install step described. Qt is only needed if you build from source, where the verified combinations are Qt 5.15.2, Qt 6.5.3 and Qt 6.8.3.

### Is JQTools available as a browser tool?

Yes. An online WASM build is documented at https://web.jasonserver.com:10035/JQTools/JQTools.html, and Qt 6.8.3 plus WASM is one of the four verified build environments.

### Which third party libraries does JQTools bundle?

ZXing, qrencode, Zopfli with LodePNG, Guetzli with Butteraugli, and Mbed TLS, all included as source and referenced through JQTools.pro and library/JQLibraryImport.pri. Hash calculation uses Qt's own capability such as QCryptographicHash instead.

### Can JQTools encrypt a password directly?

It offers RSA key pair generation in PEM, RSA encrypt and decrypt with Base64 ciphertext, AES-CBC with PKCS#7 padding and Base64 input and output, and HMAC-SHA256. The README does not document a password based encryption or key derivation flow, so you would have to generate and protect a key yourself.

### Is the PNG compression in JQTools lossless?

The PNG compressor is built on Zopfli and the README states the compression is lossless. JPG compression uses Guetzli and is lossy.

## Sources

- [188080501/JQTools on GitHub](https://github.com/188080501/JQTools)
- [Issues](https://github.com/188080501/JQTools/issues)
- [License: MIT](https://github.com/188080501/JQTools/blob/master/LICENSE)
- [README](https://github.com/188080501/JQTools/blob/master/README.md)
- [Releases](https://github.com/188080501/JQTools/releases)

---

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