FreeCAD is a mature, open-source parametric 3D CAD application with a modular workbench architecture. The codebase reveals a well-structured monolithic desktop application written in C++ with extensive Python bindings. The core uses OpenCASCADE as its geometry kernel, Coin3D (Open Inventor) for 3D scene representation, and Qt for the GUI. The architecture separates the application logic (App) from the GUI (Gui), with a Base layer providing fundamental utilities (math, units, persistence, Python integration). Workbenches (PartDesign, Sketcher, Draft, Arch, FEM, CAM, Mesh, etc.) are implemented as loadable modules that extend the document-object model. The parametric engine supports expression-driven constraints, a full dependency graph with topological naming, and a sketcher solver for 2D constraints. The FEM workbench includes a solver framework supporting CalculiX, Elmer, and Z88. The CAM workbench provides CNC toolpath generation with post-processing. The codebase demonstrates strong engineering practices: comprehensive unit tests, CI/CD pipelines, modern CMake, C++17, and clean separation of concerns. With 31k+ stars and active development (last commit June 2026), it's a production-grade CAD system used by hobbyists and professionals alike.
JASP (Jeffrey's Amazing Statistics Program) is a cross-platform statistical analysis software that provides a GUI for conducting both Bayesian and frequentist statistical analyses. Built with the Qt framework using a C++/QML hybrid architecture, it offers point-and-click interface for statistical tests, data import/export capabilities for multiple formats (CSV, Excel, SPSS, etc.), integration with R for computations, and a modular system for extending functionality. The application features computed columns, data filtering, variable transformations, OSF cloud integration, encryption for file security, and result export to HTML/PDF.
PrismLauncher is a sophisticated Minecraft launcher application built with C++ and Qt that enables users to manage multiple Minecraft instances, mods, resource packs, and authentication. It features a modular architecture with clear separation between core application logic, instance management, UI components, mod platform integrations, networking, task-based asynchronous operations, and settings management. The application supports launching Minecraft with custom configurations, handles Mojang/Microsoft authentication, integrates with various mod platforms (Modrinth, CurseForge/Flame, FTB, Technic), and provides extensive customization options for gameplay experience.
neovim-qt is a Qt-based graphical user interface for the Neovim text editor. It provides a full-featured GUI frontend that communicates with Neovim via the msgpack-RPC protocol, supporting all standard editing operations, multiple windows, tabs, popup menus, scrollbars, and a file tree view. The application is cross-platform (Windows, macOS, Linux) and integrates deeply with Neovim's extended UI features, including external popup menus, tablines, and grid-based rendering. The architecture is modular: the core library (neovim-qt) handles RPC communication via MsgpackIODevice and NeovimConnector, while the GUI layer (neovim-qt-gui) provides the main window, shell widget, input handling, and UI extensions. The ShellWidget is a standalone, reusable Qt widget that renders a terminal-like grid of cells with full color, font attributes, cursor blinking, and ligature support. Input events are converted to Neovim's key notation through platform-specific modules. The application also includes a VimL plugin (nvim_gui_shim.vim) that exposes GUI commands like GuiFont, GuiTabline, and GuiScrollBar. Key entry points include main.cpp (application startup), App class (command-line parsing and window management), MainWindow (orchestrates shell, tabline, scrollbar, treeview), and Shell (manages Neovim attachment and redraw notifications). External dependencies are Qt6, msgpack-c, and Neovim itself. The build system uses CMake with support for various package managers and CI pipelines (GitHub Actions, CircleCI, Azure Pipelines).
This repository is a fork of Prism Launcher specifically modified to enable offline Minecraft gameplay without Microsoft/Mojang authentication. It's a cross-platform desktop application built with the Qt framework that manages Minecraft instances, handles mod installation from various sources (Modrinth, CurseForge, FTB, etc.), and launches the game with configured settings. The application features a modular architecture with separate components for core logic, Minecraft-specific functionality, user interface, mod platform integrations, networking, and task management. Key features include instance management, version control, mod/resource pack handling, Java installation management, screenshot capabilities, and offline authentication support.
Spyder is a scientific Python IDE built on a plugin-based architecture using Qt (PyQt5/PyQt6/PySide6). It provides a multi-language code editor with Language Server Protocol (LSP) integration for completions, diagnostics, and formatting, an IPython/Jupyter console with custom kernel management, a variable explorer for inspecting NumPy/Pandas objects, a debugger, profiler, and a help system that renders documentation with MathJax for mathematical notation. The main entry point is `spyder.app.start:main`, which initializes the main window and loads plugins discovered via setuptools entry points under the `spyder.plugins` group. Each plugin (e.g., Editor, IPythonConsole, VariableExplorer) is a self-contained module with its own configuration page, container widget, and status bar integration. External dependencies include `spyder-kernels` (custom Jupyter kernels), `python-lsp-server` (LSP backend), `qtconsole` (Qt-based console widget), and `spyder-remote-services` (remote kernel execution via JupyterHub). Data flows: user edits code in the editor, which communicates with the LSP server for completions and diagnostics; running code sends it to the IPython kernel, which executes and returns results displayed in the console and variable explorer. The architecture is a monolith with a formal plugin API that supports lifecycle hooks, dependency management, and configuration observers.
Binance Grid Trader is a cryptocurrency trading bot that implements grid trading strategies for Binance Spot and Futures markets. The application features a modular architecture with separate layers for exchange gateways, event processing, strategy management, and user interface. It provides both a graphical interface built with PyQt5 and script-based execution modes for running trading strategies without UI. The system connects to Binance via REST and WebSocket APIs to receive market data and execute trades based on configurable grid strategies.
napari-chatgpt (Omega) is an LLM-powered autonomous agent designed as a napari plugin for interactive image analysis. It enables users to interact with the napari viewer via natural language through a chat interface, either embedded in napari or via a web-based UI. The system processes user commands by leveraging LLMs (via LiteMind) to select and execute appropriate tools for tasks such as image loading, segmentation, denoising, widget creation, viewer control, web search, and code execution. The architecture centers around a plugin-contributed dock widget that launches a chat interface, which communicates with a FastAPI/WebSocket backend. The backend hosts the Omega agent, which uses a modular tool system where each tool (e.g., for file operations, segmentation, or web requests) inherits from a base class and is responsible for executing specific actions. The agent can iteratively refine its actions through dialogue, enabling complex workflows like 'segment nuclei and show measurement statistics'. Key external dependencies include napari (>=0.5), LiteMind, LLM provider libraries (OpenAI, Anthropic, Google), FastAPI, Qt bindings, and scientific libraries like scikit-image, Cellpose, and StarDist.
Fluorine-Manager is a Linux-native mod manager derived from Mod Organizer 2, designed to manage game modifications without altering the original game files. It employs a virtual file system (VFS) using FUSE to overlay mod files, enabling safe mod installation and conflict resolution. The application features a Qt-based GUI with extensive plugin architecture supporting Bethesda games (Skyrim, Fallout series) and non-Bethesda titles through Python and C++ plugins. Core functionality includes mod organization, load order management, BSA/BA2 archive handling, INI file manipulation, and integration with Nexus Mods and Steam/Proton for Windows game compatibility on Linux. The system follows a modular design with clear separation between core logic, game-specific implementations, and utility libraries.
Plater is a 3D printer parts placer and optimizer that takes STL files and configuration parameters to generate optimized print plates. It uses a heuristic based on greedy algorithm with brute force to arrange parts on print plates, minimizing the number of plates needed. The system features both a Qt-based GUI for interactive use and a command-line interface for automation. The architecture cleanly separates the core placement algorithm (in the plater/ library) from the user interface (in gui/), with the core library handling STL parsing, bitmap-based part representation, and the optimization algorithm. The placement algorithm pixelizes parts into bitmaps, applies spacing through dilation, and uses a gravity-inspired scoring system to position parts, running multiple iterations with different parameters to find the optimal solution.
Rusted PackFile Manager (RPFM) is a desktop application for modding Total War games. It provides comprehensive tools for opening, editing, and saving proprietary game pack files (.pack) and dozens of embedded binary formats (animations, models, sound banks, battle maps, UI layouts, etc.) across all major Total War titles from Empire to Warhammer 3. The application is built in Rust with a Qt6 frontend, using a client-server architecture where the UI delegates heavy file operations to a background server over WebSocket. It also exposes a headless server with WebSocket and MCP endpoints for AI tool integration. The codebase is modular, with separate crates for core library (`rpfm_lib`), extended features (`rpfm_extensions`), IPC protocol (`rpfm_ipc`), telemetry (`rpfm_telemetry`), and shared UI utilities (`rpfm_ui_common`). It includes custom C++ Qt widgets, a plugin scripting system (Lua/Python), and self-update capabilities.
trdrop is a desktop application for analyzing uncompressed video files to estimate real frame rates, frame times, and detect screen tearing. Built with Qt/QML for the UI and C++/OpenCV for core processing, it supports simultaneous analysis of up to 3 videos. The application features a pipeline architecture: video capture → frame processing (difference calculation, framerate/frametime estimation, tear detection) → image conversion → composition → rendering (with configurable graphs and overlays) → export (image sequences or CSV). Key strengths include sophisticated tear detection logic that adjusts frame rate calculations for partial frame tears, clean separation between UI and processing logic, and dynamic resolution-adaptive rendering. The project is actively maintained with recent commits and a functional CI/CD pipeline for Windows builds.
Strecs3D is a specialized desktop application designed to optimize 3D printing infill density through Finite Element Method (FEM) analysis. The software ingests CAD geometry (STEP/STL) and optional stress analysis results (VTU), segments the mesh based on stress thresholds, and exports variable-density 3MF files compatible with major slicers like Cura, Bambu Studio, and PrusaSlicer. It serves as a bridge between structural engineering simulation and additive manufacturing, allowing users to reduce material usage while maintaining structural integrity. The architecture is built on Qt 6 for the user interface and VTK for 3D visualization, compiled via CMake with vcpkg for dependency management. The application follows a modular design with a clear separation between the UI layer, core processing logic, and FEM pipeline integration. It supports a full simulation workflow, converting STEP files to CalculiX input (INP), running the solver, and converting the output (FRD) back to VTK format for visualization and processing. Data flows from geometry import through optional FEM simulation to mesh segmentation and 3MF export. The system relies heavily on external tools (CalculiX, Gmsh, OpenCASCADE) which are integrated via custom ports and wrappers. While the internal C++ code demonstrates professional engineering practices, the heavy coupling to external binary dependencies and platform-specific build configurations introduces maintenance complexity. The codebase is actively maintained with recent commits and a low issue count relative to its popularity. However, technical drift is present due to hardcoded paths for external solvers and custom patches for Gmsh, which require careful version management to prevent breakage in deployment environments.
TOra is a database administration and development toolkit primarily for Oracle but also supporting MySQL, PostgreSQL, DB2, and Teradata. It provides a modular Qt-based GUI application with database connection management, SQL worksheet with syntax highlighting and execution, schema browser, result viewing/exporting, PL/SQL editor/debugger, tuning tools, backup utilities, and security/session management. The architecture follows a plugin/extension pattern where tools inherit from base classes, uses MVC for result display, and implements abstraction layers for database connectivity. Key entry points are in src/main/ for application startup, connection dialogs, and preferences.
This repository implements a local AI assistant for Windows with a focus on privacy and offline operation. The application features a modern Qt-based GUI with multiple tabs for chat, planning, briefing, home automation, and web search. It includes a voice pipeline with wake word detection ('jarvis'), speech-to-text, intent classification via a fine-tuned FunctionGemma model, local LLM inference through Ollama, and text-to-speech using Piper TTS. Core functionalities encompass smart home control (TP-Link Kasa), calendar/task management, weather/news aggregation, and system monitoring. The architecture is modular, separating concerns into core services (LLM, router, function execution, voice assistant) and GUI components, with communication via Qt signals and slots. Data is stored locally in SQLite databases. The project demonstrates thoughtful engineering in areas like reactive settings management, model persistence for VRAM optimization, and reusable UI components, though it maintains some Windows-specific dependencies and tight coupling in certain areas.