Entropic is a local-first desktop AI workspace built with Tauri and React. It provides a full desktop environment including chat with an AI agent, file management (Finder), web browsing, office document editing (OnlyOffice integration), voice control, task board with cron jobs, and an integration marketplace (OAuth for Google, Outlook, Slack, etc.). The application runs a sandboxed runtime (OpenClaw) inside Docker/Colima on macOS/Linux or WSL2 on Windows, ensuring secure execution of agent actions. Communication with the agent gateway happens via WebSocket with structured RPC frames. The system supports two modes: local API keys (user provides LLM keys) and managed proxy mode with hosted authentication and billing via Supabase/Stripe. The architecture is a monolith with separate microservices for browser automation (Playwright) and skill scanning (Cisco AI Defense). The frontend uses React 18, TypeScript, Vite 5, and Tailwind CSS 4, while the backend is Rust with Tauri v2 plugins for deep-link, updater, store, stronghold, and shell access. The codebase demonstrates strong engineering practices with reusable hooks for audio recording/transcription, a custom markdown renderer with workspace link support, and a resilient WebSocket client. However, some components are monolithic (Chat.tsx ~4000 lines, Files.tsx ~3000 lines) and there are hardcoded model lists and pricing that may drift over time.
This repository provides `react-photo-view`, a React component library for image and custom element preview with touch gestures, animations, and keyboard navigation. The library exposes three primary components: `PhotoProvider`, `PhotoView`, and `PhotoSlider`. `PhotoProvider` manages a group of images via React context, tracks visibility and index, and renders a `PhotoSlider` portal. `PhotoView` registers individual images or custom render nodes with the provider and handles thumbnail click/double-click triggers. `PhotoSlider` renders a full-screen overlay with a backdrop, swipeable carousel, zoom/pan/drag support, and optional toolbar/overlay customizations. The architecture is monolith-like within the library but decoupled through context and custom hooks. Key entry points are the `PhotoProvider` wrapper and `PhotoView` child components. External dependencies include React 16.8+ and ReactDOM. The codebase demonstrates strong craftsmanship: physics-based scrolling, debounced/tap gesture handling, and modular utility functions. No unit tests are present, and TypeScript version (4.9) and some dependency versions are slightly behind current, but the library is actively maintained and functional.
This repository, microsoft/WhatTheHack, is a comprehensive collection of hackathon challenge content focused on Microsoft Azure technologies. It contains over 70 individual 'hacks' covering topics such as Kubernetes, AI, DevOps, serverless, infrastructure-as-code, and more. Each hack includes student challenge instructions, coach solutions, and often starter code and infrastructure templates. The repository serves as a reusable library for running hands-on workshops and self-paced learning. While not a single application, it provides a structured framework for creating and delivering technical training events. The code quality varies across challenges, but the overall organization and documentation are strong, with reusable patterns like GitHub Actions workflows and hack authoring templates.
This repository provides the serving infrastructure and fine-tuning examples for MedSigLIP, a medical vision-language model (SigLIP variant) that encodes medical images and text into a shared embedding space. The codebase is dominated by a production-grade serving system: a Triton Inference Server backend wrapped in a Gunicorn application, deployed on Google Cloud Vertex AI. It includes modular data accessors for DICOM (whole-slide and generic), GCS, HTTP images, and inline bytes, with modality-specific preprocessing (ICC profile correction, windowing, dynamic range rescaling). The serving layer handles batch prediction, authentication, structured logging, and health checks. While notebooks demonstrate fine-tuning and data-efficient classifier training using Hugging Face, the core of the repository is the serving stack, making it primarily an application with strong data-research hybridity. The code is well-structured with clear abstractions (abstract data accessors, model runner, predictor), thorough unit tests, and reusable patterns like three-tier ICC profile caching and thread-safe logging. However, it is tightly coupled to Google Cloud and medical imaging standards, and some complexity arises from forking and dependency management.
Contributte Datagrid is a mature, full-featured datagrid component for the Nette PHP framework. It provides a rich set of features including filtering, sorting, pagination, inline editing, tree view, CSV export, column hiding, group actions, and aggregation functions. The component is split into a PHP backend (Nette control) and a TypeScript frontend with a plugin-based architecture (Naja AJAX, Bootstrap 5, TomSelect, SortableJS). It abstracts data sources via the IDataSource interface, with implementations for arrays, Dibi, Nette Database, Doctrine ORM/Collections, Nextras ORM, Elasticsearch, and custom API endpoints. State persistence is pluggable through IStateStorage. The library is production-ready, actively maintained with a clear changelog and upgrade guides, but shows some technical debt with long methods, static properties, and deprecated methods. It is not a data research or analytics project; it is a reusable UI component for web applications.
This repository is a curated learning-resource aggregator (an 'awesome list') for the Zig programming language, not a software application. Classified as 'application' only because of its CI/CD tooling; it is not a data_research repo either — there are no datasets, notebooks, pipelines, or application source code. The core asset is README.md, a ~200-entry categorized collection of links to Zig books, videos, podcasts, blog posts, GitHub projects, and AI/ML frameworks, organized into ~25 categories with older entries progressively moved to a yearly archive/ directory. The only code-adjacent artifacts are package.json (markdownlint-cli, markdown-link-check), two GitHub Actions workflows, and three OpenCode agent-skill definitions.
LLEf (LLDB Enhanced) is a Python-based LLDB plugin for low-level reverse engineering, vulnerability research, and exploit development. It provides enhanced debugger context (registers, stack, code, threads, trace) via an automatic stop hook and adds specialized commands: context, hexdump, pattern (cyclic pattern generation/search), checksec (ELF security mitigations), xinfo (memory mappings), dereference (pointer chain dereferencing), and scan (heap/memory scanning). It supports multiple architectures (x86_64, ARM, AArch64, i386, PowerPC) and includes experimental Go binary analysis: parsing the PCLNTAB and ModuleData structures to recover function names, types, and stack frames from stripped Go executables (versions 1.7–1.24). The plugin persists configuration via JSON files in the user's home directory. The codebase is structured with clear base classes for commands, settings, and architecture definitions, though it lacks automated tests and relies heavily on the LLDB Python API.
This is a Go-based blockchain node for the Mezon MainNet (MMN), implementing Proof-of-History (PoH) for transaction ordering, libp2p for peer-to-peer networking, gRPC and JSON-RPC for external APIs, and a leader-based consensus protocol with vote collection. The node supports three transaction types: Ed25519 key-based transfers, Groth16 ZK-proof transfers, and user content (social interactions). It uses either LevelDB or RocksDB as the persistent storage backend, with the latter bundled as vendored C headers. The codebase includes a CLI (init, bootnode, node, transfer), a client library, a stress-test tool with HTML reports, and a migration tool for importing user balances from CSV. The architecture is modular with clear interfaces for storage, mempool, events, and networking, making it a well-structured example of a modern blockchain validator node.
AppFlowy-Cloud is the Rust backend for the AppFlowy collaborative workspace platform, providing real-time document editing via CRDT (Yrs) with WebSocket sync, REST APIs for user/workspace management, AI features (chat, completion, embeddings), file storage (S3/MinIO), and background indexing. It follows a multi-service architecture with a main Actix-web server, a background worker (Axum), and an admin frontend (Axum/Askama), all orchestrated via Docker Compose. The codebase is extensive and well-structured, with many reusable libraries for database access, access control (Casbin), real-time protocol handling, and AI client integration. A significant portion is dedicated to integration tests covering collaborative sync, file uploads, and AI operations. However, this repository is explicitly marked as a legacy open-source release. The README states it is no longer maintained; active development has moved to a closed-source commercial fork. This results in some technical drift, such as deprecated endpoints, commented-out tests, and workarounds for known issues. Despite this, the code demonstrates high craftsmanship with clean abstractions (e.g., StreamRouter, ReconnectionManager, CollabStore trait) and robust patterns for distributed systems. It serves as a valuable reference for building real-time collaborative backends, but any reuse should account for its stale maintenance status and the need to update dependencies and fix known bugs.
This is a Zsh plugin that reminds users to use defined aliases when they type a command that has an alias. It hooks into Zsh's preexec and precmd mechanisms to intercept commands, expand them, and compare against all defined normal, global, and git aliases. If a match is found and the user did not use the alias, it prints a configurable reminder message (before or after command execution). It also supports a 'hardcore' mode that prevents command execution if an alias exists, forcing the user to use it. The plugin is a single Zsh script sourced into the user's shell, with no external dependencies other than Zsh 5.1+ and optionally `tput` for colored output. It provides toggle functions (`disable_you_should_use`/`enable_you_should_use`) and a report function (`check_alias_usage`) to analyze history and show alias usage counts. The code is well-structured, includes a comprehensive test suite using zunit, and handles edge cases like sudo commands, alias chains with cycle detection, ignored aliases, and multiple display modes.
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.
g3nd is the official demo/showcase application for the g3n Go 3D game engine. It is a single Go binary that presents a windowed GUI (built on the engine's own immediate-mode GUI system) with a categorized demo tree. Users select demos that exercise the engine's capabilities: glTF/glb loading, PBR materials, animations (skinning, morph targets), audio (OpenAL), particle systems, post-processing shaders, and GUI widgets (tables, trees, sliders, form boxes, dock layouts). The application registers demos via Go's `init()` side-effect pattern: each demo package imports itself and calls `app.DemoMap["category.name"] = &struct{}{}`. The core `App` struct manages the scene graph, camera, orbit controls, and per-frame `Update` dispatch. The repository also vendors a large set of test assets (glTF sample models, Blender files, audio, textures) under `data/`. The architecture is a classic Go application: `main.go` imports all demo packages for their registration side effects, then delegates to `app.Create().Run()`. The `app` package owns the window, GUI, and demo lifecycle. Each demo implements a minimal `IDemo` interface (`Start`, `Update`, `Cleanup`). The `util` package provides reusable GUI helpers (file selectors, light meshes). The demos are grouped by category: animation, audio, experimental physics, geometry, GUI, light, loader, material, other, shader, texture. The code is idiomatic Go with clean separation, but some demos are marked experimental and the engine dependency is a pseudo-version that may drift.
WebDNN is a browser-based neural network inference engine that executes ONNX models directly on the client side. It provides four backends—CPU, WebAssembly, WebGL (1/2), and WebGPU—allowing models to run on a wide range of hardware. The repository includes a Python graph transpiler for offline model optimization (shader generation, operator fusion, 8-bit quantization) and a TypeScript runtime with a modular operator registration system. While the runtime is application-oriented (library for web ML inference), the Python transpiler contains research-grade optimization passes and weight compression algorithms, giving the project a hybrid character. The codebase is well-structured with clean abstractions for backends and operators, but some backends (WebGPU, WebAssembly) are partially complete and require specific build toolchains.
Ndless is a jailbreak and homebrew SDK for TI-Nspire calculators. It enables execution of unsigned ARM-native code and provides a complete development environment including cross-compilation toolchain, system libraries (libndls, libsyscalls), SDL 1.2 port, Lua scripting extensions, and support for multiple calculator models and OS versions (3.x through 6.x). The repository contains exploit-based installers for each OS version, a runtime loader with hooking infrastructure, and a custom executable format (Zehn). The SDK includes sample applications demonstrating graphics, input, particles, networking, and Lua integration. The codebase is heavily based on reverse-engineering of TI's firmware, with hardcoded memory addresses and syscall tables for dozens of OS releases. This is a hybrid project: primarily an application/SDK, but with a significant data/research component in the form of reverse-engineering artifacts (IDA IDC scripts) used to generate syscall mappings.
This is a production-grade backend service for an enterprise AI platform, VoiceSageX, providing Retrieval-Augmented Generation (RAG), agent-based conversational AI, multi-agent orchestration, long-term memory, and model inference. Built with FastAPI, it exposes numerous RESTful endpoints under `/Voicecomm/VoiceSageX/` for knowledge base management (document parsing, chunk editing, vector indexing), agent chat (single and multi-agent with LangGraph), MCP tool integration, and model invocation. The architecture follows a modular, pipeline-oriented design: the RAG subsystem implements a clear stage-based flow (extraction, cleaning, splitting, vectorization, retrieval, reranking) with strategy and factory patterns, while the agent subsystem uses a class hierarchy (BaseAgent → HistoryAgent → MemoryAgent) and supports streaming. The system relies on PostgreSQL with pgvector for vector storage, external sandbox for code execution, and multiple model providers (OpenAI, Azure, SiliconFlow, Ollama). Configuration is environment-aware (dev/qa/prod) and loaded from JSON files. The codebase demonstrates solid engineering practices with async patterns, Pydantic models, and consistent error handling, though there is some duplication across similar API endpoints and potential dependency drift risks from langchain and langgraph versions.
This repository hosts the documentation and tutorials for Kuboard, a Kubernetes management interface. It is built with VuePress 1.x and serves as a static site via Nginx. The site includes Markdown-based guides covering Kubernetes concepts, Kuboard installation and usage, and practical tutorials for deploying applications. Additionally, it provides version-specific installation scripts for setting up Kubernetes clusters and deploying Kuboard in various configurations (standalone, HA, etc.). The documentation is organized into sections such as Overview, Installation, Learning, Guide, and Support, making it a comprehensive resource for Kubernetes users.
This repository is a Godot GDExtension that enables using Dart as a scripting language for the Godot game engine. It provides a C++ native plugin that embeds the Dart VM, a Dart runtime library (`godot_dart`) with FFI bindings and type wrappers, and a build runner package (`godot_dart_build`) for generating boilerplate code from `@GodotScript` annotations. A binding generator tool (`tools/binding_generator`) reads Godot's extension API JSON to produce Dart bindings for engine classes and built-in types. The repo includes two example projects: a 2D game tutorial and a networking demo. It is feature-rich but explicitly experimental, with partial support for debugging, hot reload, and editor integration, and acknowledges that performance optimization has not yet been performed. The architecture is a hybrid of C++ native extension and Dart packages with code generation pipelines, making it a complex but well-structured integration layer between the Godot engine and the Dart language.
TouchTerrain is a web application and standalone tool that converts digital elevation models (DEMs) into 3D-printable terrain models (STL/OBJ). It uses Google Earth Engine as the primary DEM source, with support for local GeoTIFF files. The architecture includes a Flask web server with a frontend using Google Maps and Three.js for preview, a standalone Python script for batch processing, and Jupyter notebooks for interactive use. The core processing pipeline fetches DEM data, resamples it, tiles it, generates mesh geometry with optional walls and bottom, and bundles the output as a ZIP file. The repository also includes geospatial utilities (coordinate conversion, KML parsing, GPX path embossing) and raster cleaning functions. While the codebase is functional and well-documented, it shows signs of technical drift: multiprocessing is broken, JavaScript libraries are outdated (Three.js r71), and there is commented-out code. The project is actively maintained with recent commits and issue triage.
MainWP Dashboard is a self-hosted WordPress plugin that enables centralized management of multiple WordPress sites from a single dashboard. It provides a comprehensive admin interface for monitoring site health, managing updates (core, plugins, themes), performing backups, tracking costs, auditing activity logs, and enforcing granular access control via a custom 'Abilities' API. The architecture is modular, with separate subsystems for logs, cost tracking, API backups, and system monitoring, each with their own database tables, REST endpoints, and dashboard widgets. The plugin communicates with child sites via authenticated HTTP requests and supports both legacy and modern REST API versions. It includes an extensive test suite covering security, permissions, and regression scenarios.
PhyML is a mature C command-line application for maximum-likelihood phylogenetic inference, with optional Bayesian MCMC dating (PhyTime) and spatial phylogeography (PhyREX) modes. It reads DNA/amino-acid alignments in PHYLIP/NEXUS format, estimates substitution-model parameters, performs NNI/SPR topology searches, computes branch supports (aLRT/SH/aBayes), and outputs Newick/NEXUS trees, site-likelihood files, ancestral sequences, and JSON traces. The code is organized around shared tree/edge/node C structures, a pattern-compressed likelihood engine (lk.c), numerical optimization (optimiz.c), and model-specific modules for molecular clocks, coalescent priors, and spatial diffusion models. The architecture is a monolith of C modules compiled into multiple executables via Autotools conditionals. Main entry points are src/main.c (PhyML), src/date.c (PhyTime), and src/phyrex.c (PhyREX); a command-line interface, interactive menu, and XML configuration are all supported. Optional MPI parallelism, BEAGLE hardware acceleration, and SSE/AVX vectorized likelihood kernels exist. The codebase is research-grade and actively maintained, but carries significant technical debt: heavy #ifdef use, large commented-out experimental blocks, stub functions, hardcoded simulation constants, and no automated test suite. It is a scientific application rather than a data pipeline, though it contains simulation and cross-validation research features. The most safely reusable components are the generic numerical routines: Brent/BFGS optimizers, a dense eigen-solver, and a broad statistical/RNG utility library. These are self-contained C implementations that can be extracted into other numerical projects with minimal modification. Likelihood, tree-search, and spatial-model modules are more tightly coupled to PhyML's internal data structures and are less directly reusable. The project serves as a reference implementation for many phylogenetics algorithms, but its engineering quality varies by module.