This repository serves as a comprehensive guide and utility for managing Visual Studio Code extensions. It provides a curated list of extensions categorized by functionality (themes, productivity, data science, etc.) with descriptions and screenshots. The repository includes a PowerShell script for bulk installing extensions and a set of tools (Python and Bash) for comparing extension lists between different environments. Additionally, it contains a standalone decision tree implementation in Python, which, while not directly related to the main purpose, demonstrates solid algorithmic implementation. The main value lies in the extension recommendations and the practical scripts for managing VS Code setups, making it a useful reference for developers seeking to enhance their coding environment.
This repository is a Home Assistant custom component (integration) that provides a low-level toolkit for managing Zigbee devices over the ZHA (Zigbee Home Automation) stack. It exposes over 30 fine-grained services—attribute read/write, binding, reporting configuration, OTA firmware updates, coordinator backup/restore, and network scanning—to power users and automations that need direct access to zigpy/ZHA internals not exposed by the standard ZHA integration. It acts as a diagnostic and administrative layer for Zigbee mesh networks, delivering results via HA service responses, events, or exported state/CSV/JSON. The architecture is strictly service-driven. All commands are registered in `__init__.py` and routed through a dynamic dispatcher (`default.py`) that maps service names to modules (e.g., `attr_read` maps to `zcl_attr.command()`) via a naming convention. A shared parameter extraction layer in `utils.py` normalizes IEEE addresses, clusters, endpoints, retries, and event callbacks. Since it deeply probes the internal ZHA/zigpy stack, it relies heavily on version guards (`is_ha_ge`, `is_zigpy_ge`) and radio-specific libraries (Bellows, ZNP, EZSP), which makes it brittle across HA/zigpy releases but proactive about compatibility. The component uses HA's event bus for async feedback, supports state writing with Jinja2-like templates, and downloads OTA firmware from external repositories. While functionally strong and actively maintained, the codebase carries significant technical debt: it performs `importlib.reload` on its own modules per service call (discouraged by HA core guidelines), has thin test coverage (linting/HACS validation only), includes an undocumented user-supplied `_user.py` injection point, and contains many untested edge paths. The dynamic dispatcher and retry/parameter-util patterns are the most valuable, reusable pieces, but most modules are tightly coupled to HA configuration flow and zigpy internal APIs.
This repository is a curated collection of over 30 independent Streamlit in Snowflake (SiS) demo applications, each self-contained in its own folder. The demos span a wide range of use cases including business intelligence dashboards, LLM-powered chatbots (Cortex, DeepSeek-R1, RAG), geospatial H3 visualizations, custom UI components (AgGrid, ECharts, Slickgrid), CI/CD pipelines with Snowflake CLI, and embedding SiS into external portals via Next.js. Each app includes a `streamlit_app.py` entry point, a `data/creation_script.sql` for Snowflake object setup, and sample data. The code is educational, heavily commented, and demonstrates patterns like caching, dynamic page navigation, and local/cloud-aware connections. While the apps are not production-grade (some hardcoded values, duplication), they serve as excellent reference implementations for building SiS applications.
This repository implements Pixie, a research framework for predicting dense physical material fields (density, Young's modulus, Poisson's ratio, material ID) from 2D image observations of 3D objects. Hydra configs drive a multi-stage pipeline: Objaverse object retrieval, Blender rendering, NeRF-based CLIP feature field training (F3RM), Gaussian Splatting training, voxel grid feature extraction, VLM-based or neural material segmentation, and MPM physics simulation via the vendored PhysGaussian codebase. The pipeline.py entry point orchestrates these stages with caching and reproducibility checks, while render.py produces Blender visualizations of segmented physics fields. Real-scene mode extends the same pipeline to captured datasets using COLMAP dataparsers. The repository also contains the full PixieVerse data curation workflow: class-based Objaverse selection using sentence-transformers, large-scale parallel Blender rendering, VLM-based filtering and critique (Gemini/Claude/GPT/Qwen via the vendored vlmx agent framework), and Streamlit tools for human-in-the-loop label correction and simulation validation. The discrete (semantic segmentation) and continuous (property regression) 3D UNet training lives in the vendored Wavelet-Generation submodule, with shared utilities in pixie/training_utils.py and normalization statistics already computed in normalization_stats/. Architecturally this is a hybrid research/application repository: primarily a configuration-driven pipeline framework with CLI entry points, but also a dataset-generation and model-training workflow. It depends heavily on vendored third-party code (nerfstudio, f3rm, PhysGaussian, Wavelet-Generation, vlmx) and shells out to Blender, CUDA rasterizers, and Hugging Face. Quality is research-grade: disciplined Hydra configs, contextual config snapshots, and skip-if-exists caching coexist with hardcoded user-specific paths, commented-out dead code, and a subprocess-heavy orchestration style. Download scripts for pre-trained models and the PixieVerse dataset are included and functional.
This repository is a web-based application that serves as a museum and emulator for Chinese-developed retro games. It provides browser-based emulation for various platforms including NES/Famicom clones, Sega Genesis, Super A'can, and numerous handheld consoles (Gamate, SuperVision, Mega Duck, GameKing, etc.). The application consists of HTML/CSS/JavaScript files that load game data from JSON files and run appropriate emulator cores (JSNES for NES, Emularity/JSMESS for other systems) to allow users to play games directly in the browser. The architecture is client-side only, with responsive design for mobile and desktop access, featuring game browsing interfaces with search and pagination functionality.
gpt-review is a Python CLI tool that integrates OpenAI/Azure OpenAI models to assist with software development workflows. It provides three main functionalities: asking questions to GPT models (with optional file/context), reviewing GitHub pull requests and posting AI-generated comments, and generating git commit messages based on staged changes. The application uses a modular architecture with separate components for different functionalities: question answering (_ask.py), PR review (_review.py), git operations (_git.py), document indexing (_llama_index.py), and API wrappers (_openai.py). It leverages the knack library for CLI structure, GitPython for git operations, Requests for GitHub API calls, and LlamaIndex for context-aware queries. The tool supports both direct OpenAI API and Azure OpenAI with automatic fallback to Azure Key Vault for credentials.
This repository is a Vue.js 3 component library for building interactive node-based diagrams, inspired by react-diagrams. It provides a `Diagram` component that renders an SVG canvas with draggable nodes, ports, and links, supporting pan/zoom, grid snapping, resizable nodes, custom node types, context menus, serialization, and edit modes. The architecture is a classic Vue component library: a main `Diagram.vue` orchestrates SVG rendering via `vue-svg-pan-zoom`, while `DiagramModel` and `DiagramNode` classes manage the data model. The codebase includes extensive Storybook stories and a documentation site built with Nuxt. While functional and well-documented, the main diagram component is monolithic and mixes concerns, and some features (like port deletion) are incomplete. The library is actively maintained and uses modern tooling (Vite, TypeScript, Vitest).
This VS Code extension replaces the built-in TypeScript version with the nightly build of TypeScript (`typescript@next`), providing the latest TypeScript and JavaScript IntelliSense features. It is a small, focused extension that contributes TextMate grammars for JavaScript, TypeScript, JSX, and TSX syntax highlighting, sourced from the Microsoft/TypeScript-TmLanguage repository. The extension is designed for advanced users who want to test upcoming TypeScript features before they are officially released. The codebase is minimal: a package.json defining the extension, a set of grammar JSON files, and build scripts for updating the grammar and version. The CI pipeline (Azure Pipelines) automates the process of pulling the latest TypeScript nightly and publishing the extension. The extension is currently in a maintained state but with reduced activity, as the CI scheduled trigger is disabled to avoid picking up TypeScript 7. The grammars are large, well-structured TextMate definitions that follow standard patterns and are reusable in other editors. The overall codebase is functional and straightforward, but lacks original craftsmanship beyond the grammar modularity.
This repository is a Node.js/TypeScript library for dependency injection (DI), heavily inspired by Symfony's DI container. It provides a service container that manages object construction, autowiring (automatic dependency resolution from constructor parameter types), and service configuration via YAML, JSON, JavaScript, and XML files. The library supports advanced features such as compiler passes, service decoration, tagged and keyed services, conditional service registration, lazy loading, and graph export. It includes a CLI tool for generating configurations and inspecting the container. The architecture follows a modular design: a ContainerBuilder manages definitions and compilation, loaders parse configuration files, and a compiler runs passes in ordered phases (optimization, removal, decoration). Autowiring uses TypeScript's AST (via @typescript-eslint/typescript-estree) to scan source files and register services automatically. The library also provides validation, graph export in multiple formats (JSON, Mermaid, DOT), and a condition evaluation system for environment-aware service registration. The codebase is well-structured with clear separation of concerns, extensive tests (both JavaScript and TypeScript), and demonstrates several design patterns (compiler pass, strategy for loaders/dumpers, reference objects, condition evaluation). However, the project appears unmaintained: the last CHANGELOG entry is from 2018, dependencies are outdated (e.g., commander v8, chalk v4, TypeScript 4.6.4), and the package.json version is 0.0.0. Despite its age, the core concepts remain relevant and the code quality is solid for a library of its kind.
This repository is a Node.js library implementing an OpenID 1.0/1.1/2.0 Relying Party (client). It enables Node.js applications to authenticate users via OpenID providers by handling discovery, association, authentication, and assertion verification. The library is modular, with separate modules for HTTP requests, XRDS parsing, and extension handling (Supporting SREG, AX, OAuth, UI, and PAPE extensions). It uses a callback-based asynchronous style and provides default in-memory storage for associations and discovered information, which can be overridden for persistent storage. The codebase shows signs of age but remains functional, with a test suite that includes integration tests against real OpenID providers.
Aaia is a security analysis tool for AWS IAM and Organizations that visualizes identity and access relationships in a Neo4j graph database. It collects AWS data via CLI commands, stores it as JSON, and loads it into Neo4j for graph-based querying and auditing. The architecture consists of a modular Python application with separate components for data collection, loading into Neo4j, and custom auditing modules. Key entry points include the main Aaia.py script, the Aaia_aws_collector.sh shell script for data gathering, and specialized action/module handlers. The data flow moves from AWS CLI → JSON files → Neo4j graph → analysis results via Cypher queries or custom modules. The tool depends on Neo4j (v3.5.17 compatible), AWS CLI, and several Python packages for policy processing and Neo4j interaction.
Fwitter is a Twitter-like social media application built with React and FaunaDB. It functions as a single-page application where the frontend communicates directly with FaunaDB for all data operations, authentication, and authorization. The architecture uses React hooks for state management, React Router for navigation, and FaunaDB's User Defined Functions (UDFs) encapsulated in a query manager layer to handle data interactions securely. Key features include user registration/login, posting text/media content, liking/commenting/refweeting, following users, and searching by tags or usernames. The application demonstrates FaunaDB's capabilities for building serverless applications with fine-grained access control through roles and UDFs.
Honey Potion is a compiler framework that translates a subset of the Elixir programming language into eBPF (extended Berkeley Packet Filter) programs, targeting both tracepoints and XDP. The system works as an Elixir library (published on Hex as `honey`) where users write eBPF logic in Elixir using macros like `@sec`, `defmap`, and `fuel`. At compile time, `__before_compile__` triggers a pipeline: static analysis, optimization (constant propagation, dead code elimination, type propagation), AST-to-C translation, boilerplate generation, and C compilation via `make`/`clang`/`llc`/`bpftool`. The generated C code includes a custom runtime with heap, tuple pool, and string pool implemented using BPF maps to overcome eBPF's stack and memory constraints. The repository includes 20+ example programs (system monitors, packet filters, data structure demos) and a comprehensive benchmark suite comparing hand-written C eBPF programs to Honey-generated ones, supporting a published research paper. Although classified as an application (a compiler library), the project has strong research characteristics with reproducible artifact scripts, optimizer variants, and performance comparisons.
Backstop is a Ruby Sinatra web application that acts as a proxy for submitting metrics to Graphite/Carbon. It accepts JSON data via HTTP POST from various sources (Collectd, GitHub webhooks, PagerDuty, and custom endpoints) and forwards the metrics to one or more Carbon/Graphite listeners. The application is structured with separate components for configuration, publishing metrics, handling authentication, and parsing Collectd data using a plugin system. The Publisher class manages a pool of TCP connections to Carbon servers, randomly selecting a connection for each metric to achieve basic load balancing. It handles reconnection by resetting the connection pool on socket errors. The Collectd parser uses a dynamic plugin system to handle different Collectd plugin types, making it easy to extend for new plugin formats.
This repository is a sample application for the Google Home Local SDK, demonstrating how to create a local fulfillment for a smart light device. It consists of three main parts: the local home app (in the `app` directory) that discovers and controls the device using various network protocols (UDP, mDNS, UPnP for discovery; UDP, TCP, HTTP for control); a virtual device (in the `device` directory) that simulates a smart light using the Open Pixel Control (OPC) protocol and supports the same discovery and control protocols for testing; and a Cloud Function (in the `functions` directory) that acts as a placeholder for the cloud-to-cloud backend, handling account linking and returning placeholder responses for SYNC and QUERY intents (while deferring EXECUTE and QUERY to the local fulfillment). The local home app uses a strategy pattern to delegate discovery and execution handling to protocol-specific implementations. The virtual device encapsulates the OPC protocol logic in a reusable component that is independent of the underlying transport mechanism.
This repository is a sample GitHub App that demonstrates how to use webhooks with a GitHub App's installation token to create a bot that responds to pull request events. The application listens for `pull_request.opened` webhook events and automatically comments on the pull request with a predefined message from `message.md`. It is built with Node.js, uses the Octokit library for GitHub API interactions, and the `@octokit/webhooks` middleware to handle webhook verification and routing. The architecture is a simple HTTP server that exposes a `/api/webhook` endpoint. The code is straightforward and serves as a minimal example for developers to understand the basics of building a GitHub App. It includes environment variable configuration via dotenv, private key loading from file, and basic error handling. There are no tests, no complex data flows, and no reusable components beyond the pattern itself.
This repository is a large collection of bare-metal firmware projects for STM32 microcontrollers (F0, F1, F3, G0, G4 families), authored by Edward V. Emelianov. It contains dozens of independent example and application projects covering USB CDC virtual serial ports, CAN bus gateways, sensor drivers (BMP280, MLX90640, DHT22, DS18B20, etc.), stepper motor control, servo control, LED displays, and more. The code is written in C with direct register access (no HAL) and uses a custom USB stack with ring-buffer-based I/O. Each project is self-contained with its own main.c, hardware initialization, and command parser, typically communicating over USB or UART with a simple text-based protocol. The architecture is monolithic per project: a main loop processes periodic tasks (ADC sampling, sensor reads, CAN message handling) and responds to commands received via USB or UART. Key entry points are the main.c files in each project directory. Data flows involve sensor acquisition (ADC, I2C, SPI), optional processing (median filtering, dew point calculation), and output via USB CDC, CAN, or UART. External dependencies are minimal: only an ARM GCC toolchain and the STM32 CMSIS-like headers provided in the inc/ folder. The repository also includes KiCad PCB designs and gerber files for many projects, indicating a full hardware+software development cycle. While the code is functional and covers a wide range of embedded use cases, it suffers from significant code duplication (ringbuffer.c, usb.c, strfunc.c are copy-pasted across many projects) and lacks a centralized library or build system. Deprecated folders and multiple versions of similar projects (e.g., chronometer_v2, chronometer_v3) add clutter. The repository is best viewed as a personal collection of working examples and prototypes rather than a polished framework. However, several components (ring buffer, string utilities, USB stack) are well-implemented and could be extracted for reuse in other STM32 projects.
VoicemeeterFancyOSD is a Windows desktop application that provides a customizable on-screen display (OSD) for the Voicemeeter virtual audio mixer. It overlays real-time audio parameter changes (gain, mute, solo, bus assignments, etc.) on top of fullscreen applications without hooking into graphics APIs, using a combination of WPF, native WinAPI calls, and a custom DXGI bridge DLL. The application runs as a system tray icon and continuously polls the Voicemeeter Remote API to detect parameter changes, then displays animated OSD strips that mimic Voicemeeter's own UI style. It supports multiple Voicemeeter versions (Standard, Banana, Potato) and offers extensive configuration via an INI file and a settings window. The architecture is a hybrid .NET WPF application with a native C++ host and bridge. The main .NET assembly (VoicemeeterOsdProgram) handles UI, configuration, Voicemeeter API communication, and update management. A separate native host (VoicemeeterFancyOsdHost) loads the .NET runtime and hosts the WPF window, while a DXGI.dll bridge intercepts DirectX calls to achieve true topmost overlay behavior. Key entry points include Program.cs (application startup), App.xaml.cs (initialization), OsdWindowManager (OSD lifecycle), VoicemeeterApiClient (API polling), and BandWindow (custom topmost window). The application relies on several NuGet packages (ini-parser, WpfScreenHelper, Hardcodet.NotifyIcon, a-tg.VmrapiDynWrapExt) and internal WinAPI functions. The codebase demonstrates solid engineering practices with MVVM separation, custom reusable controls, and a modular structure. However, it suffers from maintenance risks due to its reliance on undocumented WinAPI, a fragile host process trick (renamed ApplicationFrameHost.exe), and a preview .NET version. There are no automated tests or CI pipelines, and the repository shows no recent commits, indicating a stale maintenance state. Despite these issues, several components (e.g., BandWindow, OptionsBase, Logger) are well-crafted and could be extracted for reuse in other Windows desktop applications.
This repository provides a bash script (`mnf`) and an nftables rules file (`mullvad.rules`) that enable running Mullvad VPN alongside Tailscale or Zerotier on Linux. The script orchestrates the Mullvad CLI, nftables, and the mesh networking service to ensure traffic from the Tailscale/Zerotier network bypasses the VPN (or is correctly routed) while all other traffic goes through Mullvad. It supports country selection, RAM-only servers, custom DNS, and selective teardown. The code is a single, well-structured bash script with clear functions and argument parsing. It is not a library or framework but a purpose-built tool for a specific network configuration problem. The repository has a small footprint, no tests, and no CI/CD, but it is actively maintained (last commit dated 2026-05-07, though this appears anomalous). The nftables rules file is a simple configuration that marks packets from excluded IP ranges. There are no reusable software components beyond the script itself, which is tightly coupled to the Mullvad/Tailscale/Zerotier ecosystem.
This repository contains firmware for a programmable e-ink badge using the Pimoroni Badger2040 hardware. It provides multiple applications (badge display, QR code viewer, fortune quote viewer) that can be launched via physical buttons, with a launcher managing state persistence between runs. The system is built in MicroPython and saves application state to JSON files in a /state directory. While designed as a fun project to showcase personality and retro technology affection, it demonstrates solid embedded systems practices with modular app design and persistent state management.