Low Latency GUI on top of Vulkan

Related tags

GUI ttauri

TTauri GUI library Build on Windows Version License

Currently VCPKG builds are not recommended

Due to future changes to the C++20 standard involving ABI changes in std::format and std::ranges there are some issues with compatibility between compiler and cmake versions. Please use the non-vcpkg builds which ensures that cmake and compiler versions are exactly the same.

A portable, low latency, retained-mode GUI framework written in C++

I started this library to make a portable, low latency and modern looking UI framework, which may also be used in proprietary (closed source) applications.

It is specifically designed to display information with low-latency, and at the screen's refresh rate. Special care is taken for making it easy for GUI element to observe and modify data external to the GUI.

You can find a lot more information, documentation, example code, news and blog posts on the main web site: https://www.ttauri-project.org/


  • High level API to make simple desktop applications.
  • Modern C++20 library.
  • Retained-mode GUI.
  • GUI will dynamically track the state of the application.
  • Localization and translation.
  • Animation at the screen's refresh rate.
  • Themes; including light/dark support.
  • Editable key-bindings.

Themes with dark and light mode

  • Most or all drawing is GPU accelerated with Vulkan.
  • Text is drawn using kerning, perceptional correct blending and subpixel anti-aliasing.
  • High dynamic range and high gamut color handling.

Subpixel anti-aliasing

  • Automatic application preferences storage.
  • Many support systems:
    • logging,
    • statistics,
    • text handling,
    • text template language,
    • expression language,
    • dynamic type system.


Here is some example code for an application with three radio buttons, who form a set by sharing a single value observable.

("A1", l10n("radio buttons:")); window.content().make_widget ("B1", l10n("one"), value, 1); window.content().make_widget ("B2", l10n("two"), value, 2); window.content().make_widget ("B3", l10n("three"), value, 3); return gui->loop(); } ">
int tt_main(int argc, char *argv[])
        value = 0;

    auto gui = tt::gui_system::make_unique();
    auto &window = gui.make_window(l10n("Radio button example"));
        ("A1", l10n("radio buttons:"));
         ("B1", l10n("one"), value, 1);
          ("B2", l10n("two"), value, 2);
           ("B3", l10n("three"), value, 3); return gui->loop(); } 

Platform support

The following platforms are supported:

  • MSVC - Windows 10 - x64

For hardware support see: hardware_support


If you like to help with the development or want to modify ttauri you can find instruction how to install the dependencies and how to build ttauri in the CONTRIBUTING document.

If you want to use ttauri as a library for your own application you can find instructions in the ttauri_hello_world example application's README.


The following people and companies are platinum sponsors:

There are currently no platinum sponsors.

for more sponsors please see SPONSORS.

  • App hangs, doesn't redraw (initially transparent) when screen DPI scaling is greater than 100%

    App hangs, doesn't redraw (initially transparent) when screen DPI scaling is greater than 100%

    When I build in Visual Studio in ReleaseWithDebugInfo and launch ttauri_demo.exe, I get an invisible transparent window showing nothing but a shadow (and sometimes 1-pixel opaque lines on the top and bottom).

    ttauri demo missing black lines

    Messages printed to stdout: ttauri-stdout.txt

    • Visual Studio 16.9 (release), MSVC 19.28.29914
    • 125% DPI scaling
    • Switchable graphics, Intel(R) HD Graphics 520 and AMD Radeon (TM) R5 M330 (I think only Intel is being used)
    opened by nyanpasu64 9
  • let's get some code-coverage reporting going...

    let's get some code-coverage reporting going...

    Hey T!

    This PR enables CodeCoverage reporting using OpenCppCoverage and publishing to codecov.io.

    • You would need to register on codecov.io.
    • Docs: https://docs.codecov.com/docs/quick-start
    • Currently, we have matrix with 3-builds. All reports are uploaded to codecov and then merged to generate the final report.
      • https://docs.codecov.com/docs/merging-reports
      • This might be tweaked/changed to upload only the report of the windows-2022 VC17 build.
    • For open-source repos the upload of reports works without settings a token.
    • I've setup filtering for source files, so that all test (*_tests.cpp) and googletest (build\_deps\...) files are excluded.

    Please review and comment on the code, so that we can get it into a state, where it is ready to be merged. Regards, Jens

    opened by jakoch 6
  • Fix all self assign/copy/moves.

    Fix all self assign/copy/moves.

    In many case there are custom copy and move assignment and constructors that are not save for assignment to self. Lets fix these.

    Copy / Move Constructor

    In normal situations self-construction does not happen without invoking undefined behaviour. Lets add an axiom at the start of the constructor to check for self-construction.

    tt_axiom(&other != this)

    Copy / Move Assignment

    In normal code it is possible for self-assignment. even the standard algorithms may use std::swap with both arguments referencing the same object.

    The best way to solve this is to make sure that self-assignment simply works with the normal code, without any check. In this case we need an internal comment to mark the fact that we checked this:

    // Self-assignment is allowed.

    Otherwise a check is needed, which returns *this when self-assignment is happening, we mark this fact specifically 'unlikely' because it simply shouldn't really be happening:


    The tt_short_circuit_self_assingment() should probably be a macro in required.hpp:

    #define tt_short_circuit_self_assignment(other)\
      if (&(other) == this) [[unlikely]] return *this;
    not complex improvement 
    opened by takev 6
  • Cannot build on Windows 10 x64 using MSVC or Clang

    Cannot build on Windows 10 x64 using MSVC or Clang

    I installed the latest Visual Studio and MSVC as of yesterday-ish (v14.28).

    • When I try building in Visual Studio, ttauri complains that Visual Studio bundles CMake 3.18.5 but ttauri requires 3.19.

    • When I try building in VSCode CMake, CMake complains that git_version.hpp.in is missing.

    • If I comment out the lines of code involving that file, I get lots of errors regarding using "auto" in argument position:

      [build] C:\Users\nyanpasu64\code\ttauri\src\ttauri\algorithm.hpp(272,28): error C3533: a parameter cannot have a type that contains 'auto' [C:\Users\nyanpasu64\code\ttauri\build\ttauri.vcxproj] Context: auto shuffle_by_index(auto first, auto last, auto indices_first, auto indices_last, auto index_op) noexcept

      • Adding target_compile_options(ttauri PUBLIC /std:c++latest) does not fix this issue.
    • I tried building using Clang, but found many errors when constexpr functions tried to call non-constexpr ones, or accepted/returned types with no constexpr constructors. One error I got was class tagged_id accepting a template argument basic_fixed_string Tag but erroring out due to basic_fixed_string needing template arguments. I gave up after that point.

    opened by nyanpasu64 6
  • Improve timestamping

    Improve timestamping

    Currently I use the RDTSC to retrieve the 64 bit TSC timestamp. Many modern motherboard will synchronize the clock between CPU sockets, but not all of them do.

    Therefor we should calibrate a realtime clock on the TSC for each physical CPU. This can be done by running a thread that switches between CPU by changing the affinity mask.

    We need to also switch to using RDTSCP to retrieve both the TSC and a CPU-id. The CPU-id itself is a opaque number that should accompany the TSC in a timestamp struct. Windows has the __rdtscp() intrinsic for retrieving both values.

    In the current version the timestamp is stored as a <chrono> type; cpu_counter_clock. With this change, I think we should remove the fact that this is a <chrono> type completely, because it now will include an opaque cpu_id.

    Maybe call the type cpu_timestamp, while keeping the static now() method interface. I think there should be two static method that retrieve the current timestamp, on that uses memory fences and another that doesn't. Possibly now() should be the serialising version, while the other is called non_serialising_now() or fast_now() or quick_now().

    The non-serialising version is for when you want to get the timestamp quickly but not necessarily super accurate, like when using tt_log_* functions.

    opened by takev 5
  • Use inline namespaces

    Use inline namespaces

    We need to use inline namespaces to maintain ABI compatibility. On a project this size that is probably important. We don't care much about ABI right now, since API keeps changing, but we should already start using the inline namespace in preparation.

    I wonder what to name that inline namespace. inline namespace tt_v1?

    new feature 
    opened by takev 4
  • Build Error: When not ending in -static shared libs must be on

    Build Error: When not ending in -static shared libs must be on

    Build Error: When not ending in -static shared libs must be on

    Story time: So this evening I merged main into my branch with all of its new vcpkg setup but I'm getting an error to do with BUILD_SHARED_LIBS having to be on

    The Error

    [main] Building folder: ttauri_hello_world 
    [build] Starting build
    [proc] Executing command: /usr/bin/cmake --build /home/owner/Documents/ttauri_hello_world/build --config Debug --target hello_world -- -j 10
    [build] [1/1   0% :: 0.000] Re-running CMake...
    [build] -- 
    [build] -- [VCPKG]  Configuration Overview:
    [build] -- 
    [build] -- [VCPKG]  VCPKG_VERBOSE           -> ''
    [build] -- [VCPKG]  VCPKG_APPLOCAL_DEPS     -> ''
    [build] -- [VCPKG]  VCPKG_FEATURE_FLAGS     -> 'manifests'
    [build] -- [VCPKG]  VCPKG_ROOT              -> ''
    [build] -- [VCPKG]  CMAKE_TOOLCHAIN_FILE    -> ''
    [build] -- [VCPKG]  VCPKG_MANIFEST_FILE     -> '/home/owner/Documents/ttauri_hello_world/vcpkg.json'
    [build] -- [VCPKG]  VCPKG_TARGET_TRIPLET    -> ''
    [build] -- [VCPKG]  VCPKG_DIR               -> '/home/owner/Documents/ttauri_hello_world/build/Debug/vcpkg_installed/'
    [build] -- 
    [build] -- Configuring incomplete, errors occurred!
    [build] See also "/home/owner/Documents/ttauri_hello_world/build/CMakeFiles/CMakeOutput.log".
    [build] See also "/home/owner/Documents/ttauri_hello_world/build/CMakeFiles/CMakeError.log".
    [build] CMake Error at ttauri/CMake/SetupVcpkg.cmake:154 (message):
    [build]   When the VCPKG_TARGET_TRIPLET does not end with '-static' the
    [build]   BUILD_SHARED_LIBS must be 'ON'.
    [build] Call Stack (most recent call first):
    [build]   ttauri/CMakeLists.txt:111 (include)
    [build] ninja: error: rebuilding 'build.ninja': subcommand failed
    [build] FAILED: build.ninja 
    [build] /usr/bin/cmake --regenerate-during-build -S/home/owner/Documents/ttauri_hello_world -B/home/owner/Documents/ttauri_hello_world/build
    [build] Build finished with exit code 1

    My attempt to resolve the issue

    So in the new changes at the start there are a few build options where one of these is to set BUILD_SHARED_LIBS but regardless of it being on or off, no effect is made so it makes me wonder if there is some error in the cmake code.

    opened by Caleb-T-Owens 4
  • An always up-to-date Example

    An always up-to-date Example

    It would be great if an always up-to-date example is included in the repository to showcase ALL AVAILABLE features, widgets, and capabilities of the ttauri.

    opened by shujaatak 3
  • wrap *DebugUtilsObjectNameEXT into debug mode condition

    wrap *DebugUtilsObjectNameEXT into debug mode condition

    These calls will fail in RelWithDebugInfo at vulkan_funcs.hpp #12900, because you end up in a #ifndef VULKAN_HPP_DISABLE_ENHANCED_MODE code block.

    I'm not sure, if the debug condition is the correct way to handle this. Maybe adding a define before the vulkan header would also fix this issue, e.g.

    #include <vulkan/vulkan.hpp>
    opened by jakoch 3
  • Improve IDE support by providing CMakePresets.json

    Improve IDE support by providing CMakePresets.json

    This is an upcomming change to the currently used CMakeSettings.json approach, which is specific to Visual Studio. The new CMakePresets.json file will be used by IDEs to pickup and provide the configuration presets to the users.

    VS Visual Studio will switch to this new config file format, see VS Roadmap. It will replace CMakeSettings.json which had some issues.

    VS Code Visual Studio Code is switching.

    Presets are available in CMake v3.19+.

    • https://cmake.org/cmake/help/latest/guide/ide-integration/index.html#presets
    • https://cmake.org/cmake/help/latest/manual/cmake-presets.7.html#id1


    • [ ] remove the VS specific CMakeSettings.json
    • [ ] setup CMakePresets.json
      • The file should provide reasonable defaults to configure the build environment for ttauri for multiple IDEs.
    new feature 
    opened by jakoch 3
  • Remove narrow().

    Remove narrow().

    We currently have narrow() and narrow_cast(). narrow() will throw an exception, while narrow_cast() just makes it undefined behavior.

    narrow() is problematic because it will make debugging difficult, if you really want to throw an exception on narrowing, just use an if statement.

    opened by takev 0
  • Improve tone-mapper

    Improve tone-mapper

    Currently the tone mapper only is a pass-through shader.

    Through push-constants turning off/on features we need to implement the following (process in the same order):

    • [x] Implement desaturation for alpha values below 2.0 (for window active/deactivate animation)
    • [ ] Implement high-contrast/high-saturation for accessibility.
    • [ ] Implement daltonization to improve color separation for color blindness.
    • [ ] Implement color blindness simulation
    • [ ] Map HDR/high-gamut values to SDR values. A negative alpha value can be used to pass some kind of exposure parameter for improved mapping of images (also disables desaturation).

    https://ixora.io/projects/colorblindness/color-blindness-simulation-research/ https://www.itu.int/dms_pub/itu-r/opb/rep/R-REP-BT.2446-2019-PDF-E.pdf

    new feature 
    opened by takev 0
  • Add accessibility support

    Add accessibility support

    A lot of functionality required for accessibility is also required for user-interface automation which in turn is required for user-interface testing framework. It is best if we can share the implementation among those three.

    Requirements for win32 accessibility API:

    • [ ] Each user interface element needs a unique id, probably best to use a tt::counter.
    • [ ] Add names for each type of widget. Also include translatable names.
    • [ ] The name of certain widgets such as checkboxes are the separate label-widget on the left side of the checkbox, there needs to be a link to connect a label-widget with a control-widget.
    • [ ] A widget needs a role, a enum value like: https://docs.microsoft.com/en-us/windows/win32/winauto/object-roles
    • [ ] A widget needs a state, a enum value like: https://docs.microsoft.com/en-us/windows/win32/winauto/object-state-constants
    • [ ] A widget needs a textual representation of it's value
    • [ ] A widget needs a help text.
    • [ ] There must be a text description for states of a widget if there is no label associated with that state. For example "off" state of a toggle often does not include a label. Or "on"/"off" states of radio buttons are incomplete.
    • [ ] State changes of widgets need to be reported to the accessability-server
    • [ ] Free win32 automation: With Microsoft Active Accessibility 2.0, servers can return E_NOTIMPL from IDispatch methods and Microsoft Active Accessibility will implement the IAccessible interface for them.
    new feature 
    opened by takev 0
  • Linux port

    Linux port

    [edited by: @takev ] The following tasks need to be done to complete this issue:

    • [ ] Compile with gcc/clang. (blocked on c++20 support)
    • [ ] Port to dbus for desktop services.
    • [ ] Port to X11 for window, keyboard, mouse support.
    • [ ] Port to posix

    [original by: @jhalakpatel ] Can you please run ttauri on Linux (in my case Ubuntu) and update the CMake file and document the requirements to build ttauri on linux in the readme file?

    Once the VSG integration completes then I myself would start using ttauri full time but I see there is no support for Linux.

    new feature blocked 
    opened by shujaatak 3
  • v0.6.0(Apr 12, 2022)

    The changes in this version are pretty random, but there is a theme of improving how to create custom widgets.

    • The ttauri project is renamed to HikoGUI.
    • The drawing API is more consistent and capable; for example adding color gradients, convex quads and allowing glyphs to be overlapped.
    • New text-shaper and text widget which handles bidirectional text, with bidirectional-double cursors, multiple paragraphs, and sharper rendering by scaling and positioning to sub-pixel boundaries.
    • Improved grid widget which now supports row- and column-spans.
    • New grapheme-cluster type that can be used inside std::basic_string.
    • An central API to retrieve user-settings from the operating system, including a notifier for the application to directly react on changes.
    • DPI scaling is implemented by scaling the measurements of a theme.
    • Multi-monitor support for positioning and maximizing.
    • co-routine task and scoped_task which can await on notifiers and observables to handle complex user interface interactions and window ownership.
    • New blocking main event-loop with more accurate vertical-sync support; improving animations even in debug builds.
    • Improved localization support with language_tags that have access to ISO-codes for language, script and region.
    Source code(tar.gz)
    Source code(zip)
  • v0.5.1(Oct 11, 2021)

    • Fix bug: pre-main initialization order of global_counter.
    • Make it easier to build out-of-tree application without vcpkg.
    • vcpkg builds are not recommended at the moment due to future changes of std::format and std::ranges to the c++20 standard. Please build using non-vcpkg to ensure equal versions of cmake and the compiler.
    Source code(tar.gz)
    Source code(zip)
  • v0.5.0(Sep 29, 2021)

    The changes in this version are pretty random, but there is a theme of improving the application developer's view of the API.

    • Removing the singletons of gui_system, gfx_system, audio_system, vertical_sync, theme_book, font_book, keyboard_bindings and preferences. These are no longer owned by the ttauri library, instead they may be owned by local variables in the application.
    • Improve performance of the font-book by letting the application hold a reference to individual fonts directly.
    • Wrote a how-to for logging, counting and tracing:
      • Improved performance of counters.
      • Improved performance of tracing.
      • Logging is now done in local time.
      • Replaced tt::hires_utc_clock with std::chrono::utc_time<std::chrono::nanoseconds>
      • Reimplemented CPU-timestamp-counter conversion using std::chrono::utc_clock.
    • Wrote a how-to for application preference:
      • Implemented JSON-path for selecting values in a JSON file.
      • Reimplemented a robust UTF-8, UTF-16, UTF-32 codec for properly handling invalid encoded text strings.
      • Reimplemented dynamic data type tt::datum.
      • Implement tt::pickle system to convert between custom types and tt::datum.
      • Reimplemented observables with better automatic ownership model and better callback handling.
      • Multiple preference-files may now be opened at the same time.
    • Preparing for a how-to for writing custom widgets:
      • Replaced flat shader with a better optimized rounded box shader.
    • Add address-sanitizer builds.
    • Finalize BON8 (Binary Object Notation 8) specification.
    Source code(tar.gz)
    Source code(zip)
  • v0.4.0(Jul 10, 2021)

    This version is focused on making it practical for application developers to start using the TTauri framework to create GUI application.

    For this reason a lot of work has gone into improving the consistency between widgets and adding documentation and example code.

    The GUI system itself and application instantiation has been simplified to reduce the amount of unnecessary preamble code.

    Here are some of the important changes for this release:

    • The GUI system and widgets are easier to use and more consistent.
      • Simple unique pointer ownership of windows and widgets.
      • Widgets track delegates and callbacks using weak pointers.
      • Most widgets are non-template classes.
      • Simplified construction for widgets using the observer pattern.
    • Added examples and documentation on how to use GUI widgets.
    • Easier to use optional subsystems initialization.
    • The event loop and rendering are now done on the same thread.
    • Minimum CPU requirements x86-64-v2: Sandy Bridge and Jaguar/Bulldozer
    • Reduced dependencies to only:
      • Vulkan SDK
      • CMake
      • C++20 compiler (MSVC)
      • Vulkan Memory Allocator (automatically installed by CMake or vcpkg)
      • Google Test (automatically installed by CMake)
    • And optional dependencies:
      • Doxygen
      • RenderDoc
      • vcpkg
    Source code(tar.gz)
    Source code(zip)
  • v0.3.0(Mar 17, 2021)

    In this version we concentrated on making it easy for developers to install ttauri as a dependency for their own projects through vcpkg.

    Here are some of the important changes for this release:

    • Removed the embedded dependencies and instead making them installable via vcpkg.
    • Made a vcpkg ttauri-port so that ttauri can be used as a dependency.
    • We've made several API usability improvements, such as:
      • making the widget's coordinate system relative to the widget;
      • now using high level geometric types such as vector, point and color in as many places as possible;
      • replacing the hidden state in the draw context to explicit arguments in draw calls; and
      • changing the cell-coordinate system when placing widget on a grid layout to Excel-like cell-coordinates.
    • Fixed several bugs.
    • Made several documentation improvements.
    • Improved the pull-request work flow with continuous integration requirements before merging.
    Source code(tar.gz)
    Source code(zip)
  • v0.2.3(Feb 18, 2021)

    In this release we have done the follow:

    • Remove dependency on Python
    • Add an example application.
    • Make the ttauri library be buildable stand-alone
    Source code(tar.gz)
    Source code(zip)
  • v0.2.2(Feb 17, 2021)

  • v0.2.1(Feb 17, 2021)

  • v0.2.0(Feb 17, 2021)

the ttauri project
A low latency GUI library
the ttauri project
This is a collection of widgets and utilities for the immediate mode GUI (imgui) that I am developing for the critic2 GUI

ImGui Goodies This is a collection of widgets and utilities for the immediate mode GUI (imgui) that I am developing for the critic2 GUI. Currently, th

null 95 Jun 22, 2022
NanoGUI is a minimalistic cross-platform widget library for OpenGL 3.x/DirectX11[12]/Vulkan

NanoGUI NanoGUI is a minimalistic cross-platform widget library for OpenGL 3.x/DirectX11[12]/Vulkan. It supports automatic layout generation, stateful

dalerank 68 Jul 15, 2022
Purely native C++ cross-platform GUI framework for Android and iOS development. https://www.boden.io

BODEN CROSS-PLATFORM FRAMEWORK Build purely native cross-platform experiences with Boden Website ⬡ Getting Started ⬡ API Reference ⬡ Guides ⬡ Twitter

Ashampoo Systems GmbH & Co KG 1.5k Jul 31, 2022
Elements C++ GUI library

Elements C++ GUI library Introduction Elements is a lightweight, fine-grained, resolution independent, modular GUI library. Elements is designed with

Cycfi Research 2.3k Aug 5, 2022
Minimalistic C++/Python GUI library for OpenGL, GLES2/3, Metal, and WebAssembly/WebGL

NanoGUI NanoGUI is a minimalistic cross-platform widget library for OpenGL 3+, GLES 2/3, and Metal. It supports automatic layout generation, stateful

Mitsuba Physically Based Renderer 1.1k Aug 8, 2022
A single-header ANSI C immediate mode cross-platform GUI library

Nuklear This is a minimal-state, immediate-mode graphical user interface toolkit written in ANSI C and licensed under public domain. It was designed a

Immediate Mode UIs, Nuklear, etc. 5.9k Aug 4, 2022
A library for creating native cross-platform GUI apps

Yue A library for creating native cross-platform GUI apps. Getting started Documentations FAQ Development Examples Sample apps (with screenshots) Muba

Yue 2.8k Jul 27, 2022
A barebones single-header GUI library for Win32 and X11.

luigi A barebones single-header GUI library for Win32 and X11. Building example Windows Update luigi_example.c to #define UI_WINDOWS at the top of the

Nakst 182 Jul 24, 2022
Clight GUI written in Qt.

CLight GUI Clight GUI written in Qt. Huge thanks to @FedeDP for writing Clight and Clightd, the daemons upon which this is built on.

null 56 Aug 5, 2022
YARA pattern matching scannner GUI

YARA GUI This is a GUI for the binary pattern matching scanner YARA. Features Drag and drop targets Directory scanning Compiled rule cache Favorite/re

null 9 Jul 2, 2021
It's a simple Canvas GUI for Unreal Engine 4 with mouse operation

ue4-canvas-gui It's a simple Canvas GUI for Unreal Engine 4 with mouse operation. Included elements: Rendering Text (left/center); Rendering Rects; Re

Superior. 43 Jul 28, 2022
Proof-of-concept code to reconstruct the GUI of a Xen guest running Windows

vmi-reconstruct-gui A proof-of-concept to reconstruct the GUI of a Xen VM running Windows 7. ❗ Disclaimer This repository is work in progress. It curr

Jan 12 Oct 22, 2021
Nvui: A NeoVim GUI written in C++ and Qt

Nvui: A NeoVim GUI written in C++ and Qt

Rohit Pradhan 1.6k Aug 6, 2022
✔️The smallest header-only GUI library(4 KLOC) for all platforms

Welcome to GUI-lite The smallest header-only GUI library (4 KLOC) for all platforms. 中文 Lightweight ✂️ Small: 4,000+ lines of C++ code, zero dependenc

null 6.3k Jul 31, 2022
GUI for calibrating the wacom tablet to a screen or window

wacom-settings GUI for calibrating the wacom tablet to a screen or window. Learning project for writing in C. Uses GTK4 library for the GUI and X11 li

null 21 Apr 30, 2022
rCalc is a Simple GUI Calculator

rCalc is a simple calculator created as a hobby project to improve my C programming language knowledge and GUI creation skills. GTK3 toolkit is used to create the GUI.

null 3 Aug 1, 2022
Python GUI for seeing what's happening inside a fuzzer

Fuzzwatch Fuzzwatch is a Python GUI made to show what's going on inside of a fuzzer. It is currently integrated with Manul, which is a coverage-guided

null 10 Jun 4, 2022
ChessBurger is a modern chess GUI written by Progmaster.

ChessBurger ChessBurger is a modern chess GUI written in C++. The reason I started working on a new chess GUI, is because the GUIs out there are somew

Progmaster 1 Nov 9, 2021
HoI4 Modding Tool That Does It All! Now with a QT based GUI, all your work wil be easier!

Kadaif - HoI4 Modding Tool Kadaif is a cross-platform tool meant to help you make mods for Hearts of Iron IV. With VSCode and all it's extensions, man

null 1 Dec 28, 2021