Description
This (header-only) library can be used to create an application using Qt, without the need of the
moc (MetaObject Compiler). It uses a different set of macro than Qt and templated constexpr code to
generate the QMetaObject at compile-time. It is entirely binary compatible with Qt.
Blog post presenting the project: https://woboq.com/blog/verdigris-qt-without-moc.html (2016)
Blog post with some implementation details: https://woboq.com/blog/verdigris-implementation-tricks.html (2018)
Browse code online: https://code.woboq.org/woboq/verdigris
Travis:
Appveyor:
verdigris alternatives and similar libraries
Based on the "Networking" category.
Alternatively, view verdigris alternatives based on common mentions on social networks and blogs.
-
libcurl
A command line tool and library for transferring data with URL syntax, supporting DICT, FILE, FTP, FTPS, GOPHER, GOPHERS, HTTP, HTTPS, IMAP, IMAPS, LDAP, LDAPS, MQTT, POP3, POP3S, RTMP, RTMPS, RTSP, SCP, SFTP, SMB, SMBS, SMTP, SMTPS, TELNET, TFTP, WS and WSS. libcurl offers a myriad of powerful features -
POCO
The POCO C++ Libraries are powerful cross-platform C++ libraries for building network- and internet-based applications that run on desktop, server, mobile, IoT, and embedded systems. -
C++ REST SDK
The C++ REST SDK is a Microsoft project for cloud-based client-server communication in native code using a modern asynchronous C++ API design. This project aims to help C++ developers connect to and interact with services. -
RakNet
DISCONTINUED. RakNet is a cross platform, open source, C++ networking engine for game programmers. -
evpp
A modern C++ network library for developing high performance network services in TCP/UDP/HTTP protocols. -
Simple-Web-Server
DISCONTINUED. A very simple, fast, multithreaded, platform independent HTTP and HTTPS server and client library implemented using C++11 and Boost.Asio. Created to be an easy way to make REST resources available from C++ applications. -
wdt
DISCONTINUED. Warp speed Data Transfer (WDT) is an embeddedable library (and command line tool) aiming to transfer data between 2 systems as fast as possible over multiple TCP paths. -
PcapPlusPlus
PcapPlusPlus is a multiplatform C++ library for capturing, parsing and crafting of network packets. It is designed to be efficient, powerful and easy to use. It provides C++ wrappers for the most popular packet processing engines such as libpcap, Npcap, WinPcap, DPDK, AF_XDP and PF_RING. -
cpp-netlib
The C++ Network Library Project -- cross-platform, standards compliant networking library. -
Restbed
Corvusoft's Restbed framework brings asynchronous RESTful functionality to C++14 applications. -
Silicon
A high performance, middleware oriented C++14 http web framework please use matt-42/lithium instead -
Simple-WebSocket-Server
DISCONTINUED. A very simple, fast, multithreaded, platform independent WebSocket (WS) and WebSocket Secure (WSS) server and client library implemented using C++11, Boost.Asio and OpenSSL. Created to be an easy way to make WebSocket endpoints in C++. -
RESTinio
Cross-platform, efficient, customizable, and robust asynchronous HTTP(S)/WebSocket server C++ library with the right balance between performance and ease of use -
IXWebSocket
websocket and http client and server library, with TLS support and very few dependencies -
nope.c
WAFer is a C language-based software platform for scalable server-side and networking applications. Think node.js for C programmers. -
mailio
mailio is a cross platform C++ library for MIME format and SMTP, POP3, IMAP protocols. It is based on the standard C++ 17 and Boost library. -
QuantumGate
QuantumGate is a peer-to-peer (P2P) communications protocol, library and API written in C++. -
NetIF
Header-only C++14 library for getting addresses associated with network interfaces without name lookups on Windows, macOS, Linux, and FreeBSD
InfluxDB high-performance time series database

* Code Quality Rankings and insights are calculated and provided by Lumnify.
They vary from L1 to L5 with "L5" being the highest.
Do you think we are missing an alternative of verdigris or a related project?
README
About
This (header-only) library can be used to create an application using Qt, without the need of the moc (MetaObject Compiler). It uses a different set of macro than Qt and templated constexpr code to generate the QMetaObject at compile-time. It is entirely binary compatible with Qt.
Blog post presenting the project: https://woboq.com/blog/verdigris-qt-without-moc.html (2016)
Blog post with some implementation details: https://woboq.com/blog/verdigris-implementation-tricks.html (2018)
Browse code online: https://code.woboq.org/woboq/verdigris
Documentation
For an introduction, see the tutorial.cpp. See also a more detailed documetation of the macros in the source code.
Status
Almost all features of Qt are working. The Qt test have been ported.
Features that are not yet working:
- Q_PLUGIN_METADATA: This would require compiling to the Qt's binary json. Out of scope for now.
- QMetaMethod::tag(): Not yet implemented, could be supported if needed, but is not really needed for anything. (not even tested by Qt's auto test)
- Q_ENUM: Working, but requires to repeat the name of every enum value. Could be improved.
New features compared to Qt with moc:
- Support for templated QObject.
- Support for QObject nested in another class.
How to Use
The library consist of only two headers files. You can either copy these header files in your
project, or adjust the include paths so that the compiler finds them.
You will find the headers in the 'src/' sub-directory.
Also make sure to set your compiler in, at least, C++14 mode. With qmake, you can do that with
CONFIG += c++14
.
Tested with Qt >= 5.5. Need a compiler that can do C++14 relaxed constexpr such as GCC 5.1 or Clang 3.5, or MSVC 2017
Translations
When running lupdate
, add the argument -tr-function-alias Q_DECLARE_TR_FUNCTIONS+=W_OBJECT
to
avoid the warning that your class are not using the Q_OBJECT macro.
Correspondance Table
This table show the correspondence between Qt macro and Verdigris macro:
Qt macro | Use the Verdigris macro instead |
---|---|
Q_OBJECT |
W_OBJECT(MyClass) ... W_OBJECT_IMPL(MyClass) |
public slots: void mySlot(int x); |
void mySlot(int x); W_SLOT(mySlot) |
signals: void mySignal(int x); |
void mySignal(int x) W_SIGNAL(mySignal,x) |
Q_PROPERTY(int myProperty WRITE setProp READ getProp NOTIFY propChanged) |
W_PROPERTY(int, myProperty WRITE setProp READ getProp NOTIFY propChanged) |
Q_GADGET |
W_GADGET(MyClass) ... W_GADGET_IMPL(MyClass) |
Q_INVOKABLE void myFunction(int foo); |
void myFunction(int foo); W_INVOKABLE(myFunction) |
Q_INVOKABLE MyClass(int foo); |
MyClass(int foo); W_CONSTRUCTOR(int) |
Q_CLASSINFO("foo", "bar") |
W_CLASSINFO("foo", "bar") |
Q_DECLARE_INTERFACE(MyInterface, "my.interface") ... Q_INTERFACE(MyInterface) |
Q_DECLARE_INTERFACE(MyInterface, "my.interface") ... W_INTERFACE(MyInterface) |
Q_NAMESPACE |
W_NAMESPACE(MyNs) ... W_NAMESPACE_IMPL(MyNs) |
Q_ENUM/Q_FLAG/Q_ENUM_NS/Q_FLAG_NS | W_ENUM/W_FLAG/W_ENUM_NS/W_FLAG_NS |
Who uses Verdigris ?
- Ossia Score, an interactive intermedia sequencer. (github) It uses Verdigris in productions. Verdigris allowed ossia score to use template with their QObject's, and solve some trouble with the build system.
ISOTRONIC GmbH, a provider for visual inspection QA systems for automatic glass vial manufacturing, uses Verdigris in production:
The transition from standard Qt affected more than 100 source code files and was done in not much more than a day. The reason for the switch was to be able to use a build system that has no interface for Qt's MOC process. In the rare cases of questions or problems the Verdigris team was quick and competent in resolving the issues. After more than 6 months of real-world experience we are still very happy with that decision.
If you are using Verdigris and want to appear here, please open an issue, or a pull request
Context
The macros were inspired by CopperSpice. The template code was based on previous work: https://woboq.com/blog/reflection-in-cpp-and-qt-moc.html
Differences with CopperSpice:
- Contrary to CopperSpice, this is not a fork of Qt, but just an alternative set of macro to define Qt objects and signals and slot in a way that is binary compatible with Qt, but does not require moc. This is to be used with the normal Qt. CopperSpice being an entire fork of Qt, it has more differences with Qt and is not kept up to date with all the new features coming in Qt.
- The QMetaObject is built at compile time in the read only section (like what moc does). CopperSpice builds it at run-time when the library is loaded. So CopperSpice takes more memory and load slower.
- With CopperSpice, you cannot declare your slot within the class definition.
- CopperSpice uses
__LINE__
in its macro making it impossible to declare several things in one line or to declare objects or properties from macros. - The usability of some macro was (in our opinion) improved.
- The additional Q_OBJECT_IMPL
Licence
Like Qt, this library is under the dual licence LGPLv3 and GPLv2. Being header-only, this removes many of the obligations of the LGPLv3.
If you have any questions or remark please email [email protected]