quickjscpp is a header-only wrapper around the quickjs JavaScript engine, which allows easy integration into C++11 code.

This wrapper also automatically tracks the lifetime of values and objects, is exception-safe, and automates clean-up.

Supported quickjs version: 2024-01-13 (plus patches)

You will need to apply the patches for features not (yet) present in the upstream quickjs project.

#include <quickjs.hpp>
#include <iostream>

int main(int argc, char* argv[])
{
	try
	{
		quickjs::runtime rt;
		quickjs::context ctx = rt.new_context();
		
		quickjs::value global = ctx.get_global_object();
		global.set_property("test_func",
			[&](const std::string& val)
			{
				std::cout << "test_func: " << val << std::endl;
				return val;
			});
		global.set_property("test_func2",
			[&](const quickjs::args& a)
			{
				std::cout << "test_func2 with " << a.size() << " arg(s):" << std::endl;
				for (size_t i = 0; i < a.size(); i++)
					std::cout << "    [" << i << "]: " << a[i].as_string() << std::endl;
			});
		
		quickjs::value ret = ctx.eval(
			"test_func2(test_func('Hello world!'), 3, 4.5);\n"
			"'done'");
		std::cout << "Value returned: " << (ret.valid() ? ret.as_cstring() : "[invalid]") << std::endl;
		return 0;
	}
	catch (const quickjs::exception& e)
	{
		std::cerr << "quickjs exception: " << e.what() << std::endl;
		return 1;
	}
}

More examples can be found in the example folder.

The quickjs::runtime, quickjs::context, and quickjs::value classes manage lifetime for you. quickjs::value objects are like weak references: If the quickjs::context goes out of scope, they become invalid automatically. If the quickjs::runtime goes out of scope, all quickjs::context and quickjs::value objects become invalid.

You can throw C++ exceptions and they will traverse through the QuickJS stack in a safe manner, even through several levels. No leaked objects, references, or memory.

Objects can be instantiated either "raw" or "shared". A raw object's life time is tied to the context(s), and is deleted when the last reference is dropped. A "shared" object is maintained with a std::shared_ptr, which can outlast the quickjs::context or quickjs::runtime. They can even be created directly from the application, and brought into a quickjs::context as a quickjs::value at any given time.

Along with this, object equality for classes is guaranteed. By maintaining a weak reference for classes, a new quickjs::value can be created and passed to the JS code, and comparison with any other reference to that same object will yield true.

The QuickJS library checks for leaked objects, this library takes care of cleaning them up automatically.

The same requirements in regards to multi-threading as for the QuickJS library apply to this library. It is not designed to be used by multiple threads!

• Modules
• Nicer syntax and expansion of member function arguments (requires c++17)

This is a header-only library, simply include the quickjs.hpp file and use it. You still need to link against the QuickJS library that has the required patches applied.

quickjscpp is licensed under MIT.