This repository is an Android plugin for the Android Team Awareness Kit (ATAK) that integrates with Meshtastic mesh networking technology. It enables tactical communication capabilities including position sharing, messaging, voice memos, file transfer, and external GPS functionality over Meshtastic's low-power, long-range mesh network. The application follows a modular architecture with separate components for mesh service management, CoT (Cursor on Target) event processing, voice encoding/decoding using Codec2, and reliable file transfer using fountain codes. The codebase combines Java/Kotlin for Android components with C/C++ for the Codec2 audio codec and STM32 microcontroller implementations, reflecting its dual purpose as both an Android application and embedded communications system.
This repository implements a self-hostable data integration platform for building, deploying, and managing ETL/ELT pipelines. The system features a polyglot microservices architecture: a React frontend (app-ux) for workflow visualization and configuration, two Spring Boot backend services (mgmt-svc for management APIs and ingestion-svc for event intake), and a Node.js processor for executing pipeline transformations. Core functionality includes defining sources, transformations, and destinations; scheduling pipelines via cron; monitoring execution metrics; role-based access control with SSO support; and a plugin architecture for community-contributed apps. Data flows involve ingestion services writing events to PostgreSQL queues, the processor executing transformation steps in sandboxed VMs, and delivering results to destinations. The platform emphasizes secure handling of sensitive data via encryption utilities and provides extensibility through dynamic script execution.
This repository implements an OCPP (Open Charge Point Protocol) server for electric vehicle charging stations, supporting versions 1.6, 2.0, and 2.1. It consists of two main applications: OCPP.Core.Server handles WebSocket-based communication with charging stations and provides a REST API for management operations, while OCPP.Core.Management offers an ASP.NET Core MVC web interface for configuring charge points, managing RFID tags, viewing transactions, and sending remote commands. The system uses Entity Framework Core for data persistence with SQL Server and SQLite providers, featuring a plugin architecture for extensions like custom authorization and Azure Service Bus integration. The codebase demonstrates clean separation of concerns with version-specific controllers, middleware patterns, and dependency injection, though it contains some duplication across OCPP version handlers.
LocalStack is a cloud service emulator that provides a local AWS environment for testing and development. It runs as a containerized application that mocks AWS services (Lambda, S3, DynamoDB, Step Functions, etc.) through a modular, plugin-based architecture. The system receives AWS API calls via local endpoints, routes them to service-specific mocks, and returns AWS-compatible responses. Key components include a runtime manager for service lifecycle, CloudFormation resource providers for infrastructure simulation, and a Step Functions ASL engine for workflow execution. The codebase demonstrates strong modularity, extensive use of design patterns (plugin, resource provider, state machine), and comprehensive testing. Although the repository is marked as archived (consolidated into a unified distribution), the code exhibits high craftsmanship with clean abstractions and reusable patterns.
Watt Toolkit (Steam++) is a cross-platform desktop application that serves as a multi-functional game toolbox primarily for Steam users. The system provides network acceleration via a local reverse proxy (YARP-based) with HTTPS interception, DNS analysis, and multiple proxy modes (Hosts, System, PAC, VPN, DNS intercept). It includes plugins for Steam account switching, two-factor authenticator management (import/export/recovery), game library management, ArchiSteamFarm integration for card farming, and game tools. The architecture is a modular plugin system built with Avalonia UI, .NET, and ReactiveUI, using a multi-process IPC model for privilege separation. External dependencies include WinDivert for Windows packet interception, XunYou SDK for game acceleration, and ArchiSteamFarm for automated Steam actions. The codebase demonstrates a complex but functional architecture with significant platform-specific code and some areas of technical debt.
This repository is an unofficial fork of J2ME-Loader, a Java ME (J2ME) emulator for Android. It enables running MIDlets (Java ME applications) on Android devices by implementing J2ME APIs (LCDUI, M3G, MMAPI, etc.) and using native C++ components via JNI for performance-critical sections like 3D rendering (M3G) and audio synthesis (Sonivox, TSF). The emulator includes a user interface for browsing and launching MIDlets, configuring settings, and handling permissions. It also features a dex manipulation library (dexlib) for processing DEX files to ensure compatibility with Android ART. While the emulator is functional and demonstrates solid engineering practices, it shows signs of technical drift due to deprecated Android APIs and a forked dex library that may lag behind upstream, and maintenance appears stale based on commit frequency.
This repository implements a multi-agent orchestrator system for healthcare workflows, specifically designed for cancer care/tumor board scenarios. The system coordinates specialized AI agents (Patient History, Radiology, Patient Status, Clinical Guidelines, Report Creation, Clinical Trials, Medical Research) via Semantic Kernel group chat, with an Orchestrator agent facilitating collaboration. It provides both Microsoft Teams integration and a React/Vite web interface for user interaction. The architecture includes a Python/FastAPI backend handling WebSocket connections and Bot Framework messages, agent-specific tools for data access and external API integration, and an evaluation framework for assessing agent performance. Infrastructure is provisioned via Azure Bicep templates deploying AI services, storage, compute, and networking resources.
This repository implements the Steem blockchain node (steemd), a Delegated Proof-of-Stake (DPoS) consensus platform with social media features. The system processes transactions, maintains chain state via shared-memory (chainbase) or RocksDB (MIRA) backends, and exposes a JSON-RPC API for querying accounts, blocks, market history, and social features like follows and tags. It includes a plugin architecture (appbase) for modular functionality, with plugins for witness production, P2P networking, resource credits (RC), account history, market history, and more. The codebase is written in C++17 and relies heavily on the custom fc library for asynchronous I/O, cryptography, serialization, and reflection. The architecture is a monolithic node daemon with a plugin system. Key entry points are the steemd binary (programs/steemd/main.cpp) and the CLI wallet (programs/cli_wallet/main.cpp). Data flows from P2P network messages through the chain plugin to the database, with operations evaluated by evaluators and state changes persisted via chainbase or MIRA. External dependencies include Boost, OpenSSL, RocksDB, and secp256k1-zkp. The repository also contains extensive Python test scripts for API regression and integration testing. While the codebase is well-structured and demonstrates advanced C++ patterns (static_variant, multi-index containers, reflection), it shows signs of technical drift: legacy plugins coexist with appbase plugins, conditional compilation for SMT and MIRA features, and several FC_TODO comments indicating incomplete migrations. The fc library itself is a reusable foundation but tightly coupled to the project's threading model.
Notepad-- is a cross-platform Qt/C++ desktop text editor with a Notepad++-style feature set. The production application is a monolithic Qt Widgets GUI that provides multi-tab editing, syntax highlighting for dozens of languages via vendored Scintilla/QScintilla, hex editing, file and directory comparison, encoding detection and batch conversion, find/replace across files, batch rename, macro recording, user-defined languages, theming, and an optional plugin system. The main entry point is src/main.cpp, which handles argument parsing, single-instance IPC, and session restore, then launches the central CCNotePad main window in src/cceditor/ccnotepad.cpp. Core editing behavior is implemented through ScintillaEditView and QsciDisplayWindow, while settings are persisted through QSettings and the NddSetting helper.
Mac CLI is a monolithic shell script application that provides a unified command-line interface for managing macOS systems. It implements a plugin architecture where each functionality area (DNS, SSH, Git, etc.) is implemented as a separate shell script sourced by the main 'mac' executable. The tool automates common developer tasks by wrapping native macOS commands and utilities like softwareupdate, brew, osascript, and various network tools. While functional, the codebase shows signs of age with inconsistent parameter handling, some bugs (like variable name mismatches in SSH plugin), and reliance on outdated patterns for command dispatching.
This repository contains an open-source Manufacturing Execution System (MES) built on the Qcadoo framework. It's a Java/Spring-based web application designed for discrete manufacturing industries (machining, food packaging, shoe making, clothing). The system follows a modular plugin architecture where core functionality is provided by the framework and specific manufacturing capabilities are implemented as plugins (e.g., order management, production counting, material flow, genealogy tracking). The application uses Hibernate/JPA for ORM, features a plugin system for extensibility, and is designed to run on Tomcat with PostgreSQL. While the code shows evidence of active maintenance with recent commits, it exhibits technical debt through inconsistent naming patterns, duplicated boilerplate code, and reliance on specific versions of dependencies that may cause compatibility issues with newer versions.
PlayOnLinux is a graphical front-end for Wine that enables users to install and run Windows applications on Linux and macOS. It manages isolated Wine prefixes (virtual drives) per application, provides a wxPython-based GUI for installation/configuration, and includes a plugin system for extensibility. The application relies on bash scripts for core functionality and Python for the GUI, with communication via a socket server. Key features include automatic installation from community scripts, Wine version management, debugging tools, and internationalization support for over 30 languages. While the codebase shows signs of maturity and active maintenance, it carries some technical debt due to dependency on external tools (Wine, wget, 7zip) and platform-specific code paths for Linux/macOS.
LeechCraft is a modular, cross-platform desktop internet client built with C++ and Qt. It provides a plugin-based architecture where each plugin implements standard interfaces (IInfo, IPlugin2, IHaveSettings, IHaveTabs) and can be dynamically loaded. The core handles plugin loading, entity-based inter-plugin communication, settings management via XML dialogs, and a hook system for customization. Plugins cover a wide range of functionality: instant messaging (Azoth with XMPP/IRC/Tox), web browsing (Poshuku), RSS/Atom feed aggregation (Aggregator), music player (LMP with GStreamer), document viewer (Monocle with PDF/ePub/DjVu), email client (Snails), BitTorrent client, system monitoring, power management, and more. The codebase uses modern C++20 coroutines for async operations, a custom compile-time ORM (oral) for SQLite persistence, and functional utilities (Either, Visitor, ScopeGuard). Despite its ambitious scope and well-structured plugin system, the project shows signs of age: many plugins have incomplete translations, deprecated Qt patterns (old-style SIGNAL/SLOT macros), and external dependencies that may be difficult to build with current toolchains. The last meaningful development appears to have stalled, making the repository more valuable as a reference for plugin architecture and Qt patterns than as an actively maintained application.
KindEditor is a client-side, WYSIWYG HTML editor library written in vanilla JavaScript. It replaces standard <textarea> elements with a rich text editing interface featuring a toolbar, iframe-based design mode, undo/redo stack, and a plugin system for extensibility. The architecture is built around custom DOM abstractions (KNode, KRange) that normalize cross-browser differences (IE6+, Firefox, WebKit, Opera), a widget system (KWidget, KDialog, KMenu) for UI components, and a built-in event system. The editor supports image/table/link insertion, multi-image Flash upload (SWFUpload), HTML sanitization, and MS Word paste cleanup -- all configurable through a central options object. Despite its full feature set and well-documented API, the project has been explicitly abandoned by its maintainers as stated in the README, with no upgrades planned. The codebase is heavily weighted toward legacy browser workarounds, uses an outdated build system (Grunt 0.4.1), bundles deprecated third-party libraries (SWFUpload, Firebug Lite, QUnit v1.x), and exhibits security risks (eval usage in JSON parsing). It remains functional for modern browsers but carries significant technical debt, making it unsuitable for new projects without heavy modernization.