UAssetGUI is a Windows Forms desktop application for low-level examination and modification of Unreal Engine game assets. It allows users to open, edit, and save .uasset, .umap, .pak, and .utoc files, with JSON export/import, C# scripting via embedded Roslyn, property mappings for unversioned assets, and full theming and localization. The architecture is a monolithic GUI built on .NET 10 preview, relying on the UAssetAPI submodule for serialization. Key entry points are Program.Main and Form1 (the main editor window). The application targets modders and researchers who need to inspect or alter binary asset data directly. It includes custom controls, a plugin-like script system using collectible assembly load contexts, and supports container file extraction/repacking via native binaries. The codebase is well-structured for its niche but tightly coupled to Windows Forms and the UAssetAPI ecosystem.
This repository implements a comprehensive toolkit for detecting and removing Google DeepMind's SynthID watermark from AI-generated images, primarily targeting Gemini models. It provides multiple bypass versions (V1–V4) that use pure signal-processing techniques—frequency-domain phase scrambling, JPEG degradation, elastic deformation, VAE round-tripping, and cross-color consensus codebook subtraction—to disrupt the embedded watermark while preserving visual fidelity. The codebase includes a drag-and-drop GUI, CLI tools, batch processing scripts, and a human-in-the-loop calibration workflow. It also contains extensive watermark investigation scripts that validated the watermark's presence in over 123,000 image pairs. While primarily an application (tool for watermark removal), it has a strong research character due to its analytical components and large-scale validation studies.
DxAutoInstaller is a Windows desktop application (GUI) and command-line tool (CLI) that automates the installation and uninstallation of DevExpress VCL components into Embarcadero RAD Studio, Delphi, and C++Builder IDEs. It is driven by a YAML manifest file defining component groups, their required and optional packages, and dependencies. The tool compiles packages using the Delphi compiler, registers design-time packages, manages IDE library paths and environment variables, and handles platform- and architecture-specific configurations (Win32, Win64, Win64x). The architecture consists of a shared core library (Core, DevExpress, Installations, Options, Utils, Tasks) and two front-end projects: a VCL Forms GUI using DevExpress components and a console CLI using a third-party command-line parser. The system is actively maintained with recent commits and supports the latest RAD Studio versions. The code is well-structured, modular, and demonstrates good engineering practices such as separation of concerns, use of modern Delphi features (generics, anonymous methods), and conditional compilation for shared logic.
Collision is a desktop application for generating and verifying cryptographic hashes of files. Built with Crystal, GTK 4, and libadwaita, it provides a clean GUI interface to calculate MD5, SHA-1, SHA-256, SHA-512, Blake3, CRC32, and Adler32 hashes. The application features concurrent hash calculation using Crystal's fiber system, a Nautilus extension for file manager integration, and proper handling of Flatpak sandboxed environments. It follows a modular architecture with separate concerns for UI, core functionality, and application logic.
ytDownloader is a cross-platform desktop application built with Electron that provides a graphical interface for downloading videos and audio from YouTube and hundreds of other sites using yt-dlp as the backend download engine. It features a comprehensive download manager supporting single downloads, playlists, and YouTube search, with options for format selection, quality, subtitles, compression, and output templates. The application manages its own yt-dlp and ffmpeg binaries, supports auto-updates, and includes a download history with JSON/CSV export, theming, internationalization (23+ languages), system tray integration, and a global hotkey for quick URL pasting. Architecture: The application follows a standard Electron architecture with a main process (main.js) handling window management, IPC handlers, auto-updater, system tray, and global hotkey. A preload script (preload.js) sets up a context bridge (electronAPI) that exposes filesystem operations, process spawning, clipboard access, and other OS services to the renderer. The renderer process consists of several JavaScript modules (src/index.js, src/playlist.js, src/compressor.js, src/preferences.js, src/history_ui.js, src/common.js) that handle specific views. Communication between renderer and main process occurs via Electron's IPC mechanism (ipcRenderer/ipcMain). User preferences are stored in localStorage and a JSON config file, while download history is persisted as JSON. Key entry points: main.js (Electron main process), preload.js (context bridge), html/index.html (single-page UI shell), src/renderer.js (main renderer logic with YtDownloaderApp class), src/index.js (homepage downloader), src/playlist.js (playlist downloader), src/compressor.js (video compressor), src/preferences.js (settings), src/history_ui.js (history view). External dependencies include yt-dlp (download engine), ffmpeg/ffprobe (media processing), Electron (framework), electron-builder (packaging), electron-updater (auto-updates), systeminformation (GPU detection), and SlimSelect (custom dropdowns). The application bundles these binaries or uses system-installed versions, with fallback mechanisms.
Sleek is a cross-platform desktop application (Electron + React + TypeScript) that serves as a feature-rich todo.txt manager. It reads and writes todo.txt files, providing advanced filtering, sorting, grouping, and archiving capabilities. The application features a custom filter grammar (PEG.js) for complex queries, file watching for real-time updates, due-date notifications with badge support, and a Pomodoro timer integration. The user interface is built with Material-UI components, offering a clean, customizable experience with dark/light themes and color customization. Sleek supports 16+ languages and includes optional Matomo analytics, respecting user privacy by never collecting todo content.
cimgui is a C language binding generator and wrapper library for Dear ImGui, a popular C++ immediate-mode GUI library. It provides a programmatically generated C API (cimgui.h/cpp) that exposes both public and internal ImGui functions, structs, and enums, along with backend-specific wrappers for GLFW, SDL2/3, Vulkan, OpenGL, and DirectX11. The core of the project is a Lua-based code generator (generator.lua, cpp2ffi.lua) that parses ImGui C++ headers and emits C bindings, metadata files (JSON/Lua), and backend implementations. The repository includes example applications demonstrating usage with various graphics backends and a CMake-based build system for easy integration. While not a standalone application, it serves as a foundational library for embedding Dear ImGui in C projects or for generating FFI bindings to other languages (e.g., Python, Rust, C#). The generator is designed to be extensible, supporting custom configurations and inherited types, making it suitable for binding other ImGui-based libraries like cimplot or cimnodes.
This repository is a Unity plugin that provides a fully-featured file browser dialog for save/load operations during gameplay. It supports file and folder selection, multi-selection, search, filtering, context menu operations (rename, delete, create folder), window drag/resize, and runtime theming. The plugin uses a singleton pattern to ensure only one dialog is open at a time and offers coroutine-based methods (WaitForSaveDialog/WaitForLoadDialog) for seamless integration with Unity's async system. The architecture is structured as a set of Unity scripts, prefabs, and assets. The main controller is FileBrowser.cs, which manages the dialog lifecycle and UI interactions. FileBrowserHelpers.cs abstracts file system operations across platforms, with special handling for Android's Storage Access Framework (SAF) via native Java code compiled into an .aar. The UI is built with Unity's uGUI system and includes a recycled list view for efficient rendering of large directories. Skinning is handled by UISkin.cs, a ScriptableObject that defines colors, fonts, and sprites. The plugin also includes Android-specific Java classes for directory picking and permission requests. Key patterns include object pooling (RecycledListView), platform abstraction (FileBrowserHelpers), theming via scriptable objects (UISkin), and coroutine support. The Android integration is particularly noteworthy, as it handles the complexities of the Storage Access Framework for file operations on modern Android versions. The plugin is designed to be embedded in any Unity project and is distributed as a Unity package via the Asset Store or OpenUPM.
AutoPy is a cross-platform GUI automation library implemented in Rust and exposed to Python through PyO3. It provides programmatic control of the mouse and keyboard, screen capture, bitmap pixel inspection, and color detection. The library abstracts over Windows, macOS, and X11 backends, so the same Python API works across desktop platforms. It is distributed as a Python extension module built with maturin/setuptools-rust and is also usable as a Rust crate.
LunaVox is a high-performance, cross-platform text-to-speech inference engine specialized for Qwen3-TTS models. It provides a unified C++ core with Python bindings, offering multiple interfaces: a CLI (`lunavox`), a desktop GUI (customtkinter), an HTTP/WebSocket server (FastAPI), and a Python runtime API. The architecture separates model loading, tokenization, LLM-based talker/predictor generation (via llama.cpp), and neural audio codec decoding (via ONNX Runtime) into modular components. Voice modes include base, voice cloning from reference audio, custom speaker selection, and text-described voice design. The system is designed for low-latency streaming synthesis, with benchmarks showing real-time factors below 0.2 on consumer GPUs. It includes a comprehensive model conversion pipeline from HuggingFace to GGUF/ONNX formats, a build toolchain for compiling the C++ engine, and production-ready serving with Prometheus metrics and auto-batching. The codebase demonstrates strong engineering practices with cross-platform support, structured stats contracts, and bilingual documentation, though it carries some technical debt from vendored GGUF code and platform-specific workarounds.
Sophia Script for Windows is a PowerShell-based system administration utility for fine-tuning Windows 10 and 11 installations. It provides over 150 configuration functions covering privacy, telemetry, UI personalization, security hardening, debloating, and system optimization. The tool is distributed as a PowerShell module with per-edition variants (Windows 10/11, LTSC, ARM, PowerShell 5.1/7) and includes a closed-source GUI wrapper (SophiaScriptWrapper.exe) for visual configuration. Architecture: The core is a PowerShell module (Sophia.psm1) with a preset file (Sophia.ps1) that users edit to select tweaks. The module loads private helper functions (Add-Policy, Get-Hash, WinAPI, etc.) and localization files. Execution flow: Import-TabCompletion.ps1 → InitialActions.ps1 (preflight checks) → user-selected tweaks → PostActions.ps1 (system refresh, toasts, restore points). The tool modifies Windows via registry keys, group policy (LGPO.exe), service management, scheduled tasks, and file association hashes. Key entry points: Sophia.ps1 (per edition) is the main preset; Import-TabCompletion.ps1 provides tab-completion; the Wrapper/ directory contains GUI config JSONs and the wrapper executable. External dependencies include LGPO.exe (Microsoft), WinRAR for packaging, and runtime downloads for HEVC codecs and cursor packs. The project is distributed via Chocolatey, WinGet, Scoop, and direct GitHub releases. Data flows: The script reads Windows build/version info, checks remote JSON manifests for updates, and applies changes based on user preset. It exports/imports file associations as JSON and creates restore points. Localization is handled via ConvertFrom-StringData .psd1 files in 12 languages. The tool is not a data pipeline or research project; it is a pure system configuration utility.
This is a Python application for migrating playlists and liked songs from Spotify to YouTube Music. It provides both a command-line interface (CLI) and a graphical user interface (GUI) built with Tkinter. The tool first backs up Spotify data (playlists, liked songs, liked albums) into a local JSON file using a modified version of the spotify-backup script. Then it reads that JSON and uses ytmusicapi to add or like songs on YouTube Music, employing a multi-algorithm search strategy to match tracks. The architecture is monolithic: a single package with CLI entry points defined in pyproject.toml and a GUI module. Key external dependencies are ytmusicapi, tkinter, and the Spotify Web API. The code is well-structured with clear separation of concerns (backend logic, CLI, GUI, backup) and includes retry logic for API rate limits. The search algorithm supports exact matching, extended matching, and fuzzy matching with video fallback, demonstrating thoughtful design for cross-platform music identification.
MooTool is a cross-platform developer toolbox with over 30 utilities including JSON formatting, HTTP client, regex testing, encryption/decryption, color picker, diff viewer, QR code, cron expressions, translation, image processing, PDF manipulation, code runtime, and more. The repository contains three concurrent implementations: a legacy Java Swing desktop application (with FlatLaf theming and MyBatis/SQLite persistence), an Electron+React+TypeScript rewrite (using CodeMirror, pdf-lib, and native IPC bridges), and a Tauri 2 (Rust+React) version with additional native features like screen capture, system tray, and updater integration. A macOS native SwiftUI app is also provided as a preview. The architecture is modular per tool, with shared contracts across platforms, session tracking, operation history, and vault-based note storage with Git versioning. Key entry points include the Java MainFrame, the Electron main process (electron/main/index.ts), and the Tauri Rust backend commands. Data flows are entirely local (SQLite, file vault, settings JSON) with no cloud dependency except automated translation APIs and optional update checks. External dependencies include Java runtime, Git, protoc, Tesseract OCR, system keyring, and translation web services (Google, Bing).
UFO (UI-Focused agent) and Galaxy constitute a multi-agent AI framework for automating GUI-based tasks across Windows, Linux, and mobile platforms. The system uses LLM-driven agents (AppAgent, HostAgent, ConstellationAgent) that interact with desktop applications via UI automation (UIA, COM) and execute distributed task workflows modeled as DAGs (task constellations). It includes a client-server architecture with WebSocket-based Agent Interaction Protocol (AIP), MCP tool servers, a configurable RAG knowledge substrate, and a Web UI (React+FastAPI) for real-time monitoring and control. The framework is primarily an application with strong research elements: it supports trajectory analysis, evaluation agents, demonstration learning, and configurable LLM backends (OpenAI, Claude, Gemini, DeepSeek, Ollama).
This repository is a comprehensive family of GUI automation agents (Mobile-Agent series) developed by Tongyi Lab, Alibaba Group. It provides end-to-end solutions for automating interactions across mobile (Android), desktop (Windows/macOS/Linux), and web platforms using vision-language models. The system perceives GUI elements through screenshots, grounds natural language instructions to actionable commands (click, type, scroll), and executes tasks via platform-specific controllers. The architecture includes multiple agent versions (v1-v3.5, E, UI-S1, PC-Agent) with shared core modules for perception, action parsing, and controller interfaces, alongside training frameworks (VERL) and evaluation suites (Android World, MiniWoB, Mind2Web). Key entry points are version-specific run scripts (e.g., run_ma35.py) and API services for remote agent control. The system relies on external dependencies like ADB for Android, PyAutoGUI for desktop, Playwright for web, and VLMs (Qwen series) for reasoning.
MediaInfo is a mature, cross-platform application for extracting and displaying technical and tag metadata from audio and video files. It provides a command-line interface (CLI) and multiple graphical front-ends (Qt, wxWidgets, Cocoa, VCL, UWP, Android, iOS) all sharing a common core library (MediaInfoLib). The repository contains the full source for the CLI, all GUIs, Windows shell extension, installers, and build/packaging scripts. The architecture is a classic layered design: a central Core class wraps MediaInfoLib and is consumed by each GUI via platform-specific adapters. The codebase is functional and widely used, but suffers from significant fragmentation across GUI frameworks and build systems, with legacy components (VCL, UWP) and conditional compilation adding maintenance overhead. The translation system using CSV files is well-designed and the command-line parser is robust, but most components are tightly coupled to the MediaInfo domain and not easily reusable outside the project.
GNvim is a GTK4-based Neovim GUI written in Rust. It communicates with Neovim via the MessagePack-RPC protocol, providing a native desktop experience with features like floating windows, popup menus, tabline, cmdline, and smooth animations for cursor and scrolling. The architecture is a single Rust binary split into a workspace: the main `ui` crate contains the GTK4 frontend with custom widgets (e.g., Grid, GridBuffer, Cursor, Fixedz, Popupmenu, Shell), and the `nvim-rs` library crate provides a reusable, async RPC client for Neovim with auto-generated API bindings. The system's entry point is `ui/src/main.rs`, which registers resources and launches the GTK application. Data flows bidirectionally: Neovim sends UI events (redraw, options, notifications) as RPC messages, which are deserialized into Rust types and applied to the GTK widget tree; user input (keyboard, mouse) is captured by GTK event controllers and sent back to Neovim as RPC calls. The codebase is well-structured, modular, and follows modern Rust async patterns, with extensive use of GTK4's property system and custom layout managers for complex UI composition.
de4py is a comprehensive Python deobfuscation and reverse engineering tool designed primarily for Windows environments. It combines a native PySide6 GUI with a CLI interface to analyze, unpack, and clean obfuscated Python scripts and PyInstaller executables. The core functionality relies on a modular engine architecture that supports multiple deobfuscation strategies, including legacy regex-based detection and the newer 'Onyx' engine which utilizes AST manipulation and local LLM integration for semantic recovery. It also features native C++ components for process injection and behavior monitoring, allowing users to hook into running Python processes for dynamic analysis. The architecture is split between high-level Python logic for AST transformation and low-level C++ code for system interaction. The Python side manages the deobfuscation pipeline, UI rendering, and plugin management, while the C++ side handles DLL injection, API hooking via Detours, and named pipe communication. This hybrid approach provides powerful capabilities but introduces significant platform coupling and dependency on specific Windows APIs and Python versions. The tool is licensed under CC BY-NC-4.0, restricting commercial use. While the codebase demonstrates sophisticated engineering in areas like VM lifting and AST optimization, it carries risks associated with external API dependencies (telemetry, updates), brittle regex signatures for obfuscation detection, and heavy reliance on Windows-specific system calls. It is best suited for security researchers and malware analysts working in Windows environments who require a unified static and dynamic analysis platform.
EasySpider is a visual, no-code web scraping tool that combines an Electron desktop application, a Chrome browser extension, and a Python execution engine. Users design scraping workflows via a flowchart-based UI (Vue.js) where they define steps like opening pages, clicking elements, extracting data, looping, and conditional branching. The task definitions are saved as JSON graphs. The Python backend (ExecuteStage) loads these graphs and drives Chrome using Selenium with an undetected-chromedriver fork to evade bot detection. Extracted data can be written to CSV, Excel, JSON, or MySQL. The tool also includes OCR support (ddddocr), custom JavaScript/Python execution, and Cloudflare bypass capabilities. The architecture is a hybrid desktop app with a local HTTP server (Express) that spawns executor processes and communicates via WebSocket. The Chrome extension assists in element selection and XPath generation. While the tool is functional and popular (44k+ stars), the codebase exhibits significant duplication (e.g., identical task files across platform directories, duplicated Bootstrap and content scripts), hardcoded paths, monolithic executor scripts, and mixed-language strings. Several experimental modules (LLM, federated learning) are present but not integrated. The project is actively maintained with recent commits and packaging scripts, but technical debt and drift (Bootstrap 4, Vue 2, pinned Python dependencies) are moderate.
I‑Simpa is a mature, open‑source desktop application for 3D numerical sound propagation modelling, designed for scientific acoustic simulations. The system provides a full GUI (built with wxWidgets and OpenGL) for defining acoustic scenes (sources, receivers, materials, meshes), running multiple calculation cores (particle tracing SPPS, classical theory TCR, and experimental TLM), and post‑processing results via point/surface receivers, impulse responses, and sound maps. It features a tree‑based data model with XML persistence, a Python scripting layer for automation and custom tools, and supports industry‑standard file formats (STL, PLY, GABE binary arrays). The codebase is predominantly C++ with a Boost.Python bridge, and is actively maintained by the Environmental Acoustic Research unit at Université Gustave‑Eiffel. The architecture follows a classic monolith pattern with clear separation: a core calculation library (`src/spps/`, `src/ctr/`), a 3D rendering engine (`src/isimpa/3dengine/`), a GUI layer (`src/isimpa/IHM/`), and a data manager with element/property tree. Python scripts in `SystemScript/` extend the UI through a plugin mechanism. While the project is functionally complete and validated against benchmarks, it exhibits moderate technical drift: bundled MathJax 2.7.5 (2018) for documentation, some French comments and variable names, and a few Python 2 remnants. Despite this, the component design—especially the octree spatial index, GABE binary I/O, and XML element tree—are cleanly abstracted and potentially reusable in other scientific or simulation contexts. The repository also includes extensive documentation and tutorials, though the experimental directivity feature is flagged as undocumented.