WebGPU.NET is a .NET binding library for the WebGPU API, specifically targeting WebAssembly via Blazor. It provides a low-level P/Invoke wrapper generated from Emscripten's WebGPU C header, enabling GPU compute and rendering in browser-based .NET applications. The repository includes a code generator (WebGPUGen) that parses the C header using CppAst and emits C# structs, enums, handles, delegates, and P/Invoke commands. The generated library is packaged as a NuGet package (Evergine.Bindings.WebGPU) with MSBuild integration for native WebGPU support. A Blazor WebAssembly sample (HelloTriangleWasm) demonstrates basic triangle rendering using the deprecated WGPUSwapChain API. The project is part of the Evergine ecosystem and follows the organization's binding conventions, with CI/CD pipelines and a binding manifest. While the core library is functional and the generator is effective, there are signs of technical drift: the sample uses a deprecated API, the generator has hardcoded paths and a typo, and the binding is tightly coupled to a specific Emscripten version. The repository is maintained but not actively evolving, with recent scope reduction (removal of non-browser support).
GraphDreamer is a PyTorch-based system for generating compositional 3D scenes from scene graphs. It implements a coarse-to-fine approach where objects are represented as implicit signed distance functions (SDFs) and optimized using gradient signals from 2D diffusion models (DeepFloyd IF for coarse stage, Stable Diffusion for refinement). The system takes text prompts describing objects and their relationships, constructs a scene graph, and generates 3D meshes representing the composed scene. Architecture follows the threestudio framework with modular components for data handling, geometry, materials, guidance, rendering, and system orchestration. Key entry points are in launch.py which supports training, validation, testing, and export modes via command-line interface.
This repository implements and evaluates Function Vectors (FVs) for steering large language models (LLMs) without fine-tuning. The core workflow involves computing task-conditioned mean head activations from in-context learning examples, identifying causally influential attention heads via indirect effect, summing their outputs to form the FV, and applying it during inference to elicit target behaviors (e.g., translation, inflection). The system provides a modular Python library with utilities for model loading, prompt construction, activation extraction, intervention, and evaluation, accompanied by a demo notebook and evaluation scripts for running experiments on various linguistic datasets. While the codebase demonstrates clean separation of concerns and contains reusable components for model intervention and prompt handling, it shows signs of technical drift due to dependency rigidity and architecture-specific hooks, and appears to have stagnated in maintenance with no recent updates.
This repository is a front-end todo list application built with Next.js and React, demonstrating clean (hexagonal) architecture principles. The codebase is organized into domain, application, and infrastructure layers, promoting separation of concerns and testability. The domain layer contains pure use cases and interfaces, making it highly reusable. The infrastructure layer provides implementations for localStorage and in-memory storage. The application layer uses React components to interact with the domain via use cases. Despite the strong architectural foundation, the project suffers from significant technical drift due to outdated dependencies (Next.js 11, React 17, TypeScript 4.4, etc.), indicating a lack of recent maintenance.
LOA Logs is a desktop damage meter and combat log parser for the MMORPG Lost Ark, built as a Tauri application with a Rust backend and Svelte 5 frontend. In production, it captures combat data from the game client through file watching or low-level network interception (WinDivert on Windows, packet capture helpers on Linux), parses entity/skill/buff events, and renders live DPS meters, encounter statistics, and post-raid progression analysis via ECharts dashboards. It persists encounter history to SQLite through a repository pattern with connection pooling, and enriches combat data with static game data (skill tables, NPC windows, encounter definitions) bundled as generated TypeScript/JSON files. The architecture is a hybrid desktop app: the Rust backend (src-tauri) handles log ingestion, packet parsing, entity tracking, and database persistence, while the Svelte frontend uses reactive state classes (EntityState, SkillState, BuffState) and a typed column configuration system (LogColumn) to drive tables and charts. Key entry points include the Tauri command layer, the EntityTracker module, and Svelte routes for settings and statistics. External dependencies include the Lost Ark game client, WinDivert, SQLite, and several generated game data files that must be updated with each game patch. The codebase is actively maintained (recent commits, v1.51.1 tag, 30+ tests) but carries notable technical debt: a ~6000-line repository file tightly coupled to multiple modules, legacy components (LegacyLogRDPSBreakdown.svelte) alongside new implementations, live/log component duplication, and heavy use of debug_print! macros. Game data files drift from the live game without an update mechanism, and the Node.js >=24 requirement may cause compatibility issues. Despite this, several clean patterns—composable stat modifiers, entity lifecycle management, reactive model-view state, and type-safe column configs—are genuinely reusable. This is primarily an application repo, though it embeds substantial data-processing and game-data components that give it a hybrid character.
The repository is a VuePress-powered static site that serves as a comprehensive technical knowledge base for developers. It covers a wide range of topics including front-end development (HTML, CSS, JavaScript, TypeScript, Vue, React), back-end technologies (Node.js, Express, Docker, Linux, Nginx, MySQL), DevOps practices (Git, webpack, Babel), and career development. The site is built and deployed via a GitHub Actions workflow that compiles the markdown content and pushes the generated static files to a remote server. The project maintains code quality through commit linting with conventional commits and Husky hooks. The architecture is straightforward: source markdown files in the `docs/` directory are processed by VuePress to generate a static website. The build process is triggered by npm scripts (`yarn dev` for development, `yarn build` for production). Deployment is automated through a CI/CD pipeline that uses SSH to transfer the built files to a production server. The project emphasizes consistent contribution practices through commitizen and commitlint, ensuring that all commits follow the conventional commits specification. While the content is extensive and well-organized, there are signs of technical drift, primarily due to the use of VuePress 1.x instead of the current 2.x version. Additionally, many documentation sections are marked as TODOs or placeholders, indicating ongoing work. Despite these issues, the repository remains actively maintained, as evidenced by recent commits, and provides a valuable resource for developers seeking to learn or reference various technologies.
This repository is not a software application or data pipeline; it is a GitBook-based knowledge base and career guide for software testers, written entirely in Polish. It curates learning paths, book lists, blog directories, tool-specific resources (Selenium, Appium, Playwright, JMeter, Jenkins, etc.), certification guidance (ISTQB and others), job-search advice, remote/crowd testing opportunities, salary reports, and community/conference listings for the Polish QA ecosystem. There is no executable source code, API, CLI, or test suite; the 'application' classification is forced because the repo is a static documentation site rather than a data research project.
ts-liveview is a full-stack real-time web application framework written in TypeScript, inspired by Phoenix LiveView. It enables building reactive user interfaces with minimal client-side JavaScript (~13KB gzipped) by rendering HTML on the server and applying incremental DOM updates over WebSocket. The architecture is a monolith: an Express server handles HTTP/WebSocket, SQLite (via better-sqlite3-proxy) persists data, and a custom JSX runtime serializes UI components into HTML strings. Client-side logic is limited to a lightweight WebSocket client (`ws-lite`) that interprets server-issued DOM commands (update text, attributes, append/remove nodes) by CSS selectors—no virtual DOM is involved. The framework supports multiple rendering modes (SSG, SSR, streaming, hybrid MPA/SPA), includes a rich set of reusable UI components (Router, Page, Navbar, Pagination, DataTable, Chart, ComboBox, etc.), built-in localization and i18n, rate limiting, geolocation logging, and PWA manifests. A suite of demo pages (thermostat, chatroom, form, upload, pagination, timeline) demonstrate real-time state synchronization across clients. External dependencies include Express, ws, knex, better-sqlite3, chart.js, swiper, ionic, and Prism.js for syntax highlighting. While the framework is functionally complete and exhibits strong engineering in its JSX AST handling and WebSocket update protocol, the repository includes many demo artifacts, placeholder templates, and a large surface area that may drift over time. The custom build pipeline (esbuild) is bespoke, and several components show code comments or `console.log` calls indicating development-stage code.
This repository provides the official PyTorch implementation of TaDiCodec, a text-aware diffusion speech tokenizer accepted at NeurIPS 2025. The core contribution is a novel speech codec that achieves ultra-low bitrate (0.0875 kbps at 6.25 Hz) by combining a non-autoregressive Llama encoder, binary spherical quantization (BSQ), and a flow-matching diffusion decoder conditioned on text and prompt speech. The repo also includes token-based zero-shot TTS models: an autoregressive (AR) model using LLMs (Qwen2.5, Phi-3.5) and a masked diffusion (MGM) model. Inference pipelines with automatic model downloading from Hugging Face are provided. Training scripts for the tokenizer are partially implemented (dataloader, trainer class), but TTS model training scripts are incomplete. The project has migrated to a new repository (AmphionTeam/Diffusion-Speech-Tokenizer), and this repo is no longer the primary development branch, though recent commits indicate some ongoing activity.
Timeasure is a Ruby gem for transparent method-level runtime profiling in production environments. It uses `Module#prepend` and metaprogramming to intercept method calls on classes and modules that include the `Timeasure` module, measuring execution time via `Process.clock_gettime(Process::CLOCK_MONOTONIC)`. The gem provides class macros (`tracked_instance_methods`, `tracked_class_methods`, etc.) to declare which methods to profile, and a direct `Timeasure.measure` interface for manual instrumentation. Measurements are aggregated by method path (class and method name) and optionally segmented by custom values, stored in an in-memory `ReportedMethodsHandler`, and exported via `Timeasure::Profiling::Manager.export`. The architecture is a simple library with configurable procs for post-measurement handling and error rescue, allowing users to integrate with external services like New Relic or Keen.io. The codebase is small, well-tested, and cleanly structured, but has not been updated since 2018, leading to outdated dependencies and a Ruby version target of 2.1+.
The Uniswap Routing API is a serverless AWS Lambda service that provides swap quotes across Uniswap V2, V3, V4, and mixed protocols on 20+ EVM chains. It is deployed via AWS CDK with API Gateway, DynamoDB for route/pool caching, S3 for token lists and pool snapshots, and CloudWatch for monitoring. The core quote handler (`lib/handlers/quote/quote.ts`) validates inputs, selects protocols, and delegates to the `@uniswap/smart-order-router` engine. A sophisticated RPC provider layer (`UniJsonRpcProvider`, `SingleJsonRpcProvider`) manages multi-provider failover, health checks, and latency-based selection. Traffic switching experiments (`TrafficSwitcher`) enable gradual rollouts of new implementations with shadow sampling. The system also includes cron-based pool caching, GraphQL-based token fee fetching, and extensive CloudWatch dashboards. While primarily an application, it incorporates data pipeline elements for caching and token list management. The codebase shows signs of deprecation (DECOMMISSION_FAILURE_RATE = 1 in the quote handler) and contains several hardcoded configurations and temporary workarounds, but overall demonstrates solid engineering with reusable abstractions.
The speculation library provides cancellable promises as a drop-in replacement for standard JavaScript promises. The core functionality is implemented in src/index.js, where the speculation function wraps the native Promise constructor to accept a cancellation promise. When the cancellation promise resolves, it triggers a cleanup handler before rejecting the speculation. The library also includes a wait utility (src/wait.js) that uses speculation to create cancellable delays. The implementation is self-contained, relies only on native Promises, and follows the Promise/A+ specification. Despite its small size, the solution demonstrates careful handling of edge cases like settlement before cancellation and error propagation in cancellation handlers.
This is a Redmine plugin that adds helpdesk functionality by enabling email-based ticket creation and facilitating email communication with ticket submitters. The system patches Redmine's core MailHandler, Journal, and Mailer classes to intercept incoming emails, track sender information, and send notifications to support clients when ticket updates are made. Key features include customizable email templates with macro expansion, CC handling, automatic reopening of closed issues via email, and support for anonymous users as support clients. The architecture follows Redmine plugin conventions with clear separation between mailers, view hooks, and core functionality patches.
This repository provides custom nodes for ComfyUI to enable Deforum-based animation generation. It implements frame-by-frame processing of stable diffusion models with parameter scheduling, allowing users to create animated sequences by evolving prompts, seeds, strength, and other parameters over time. The architecture centers around ComfyUI's node system, with specialized nodes for parameter scheduling, prompt engineering, sampling, latent caching, ControlNet integration, image processing, logic control, video I/O, audio synchronization, and advanced noise generation. A critical execution hijack mechanism modifies ComfyUI's internal processing to handle list operations for frame sequences. The system relies on external libraries like Deforum Studio, ControlNet, RAFT, depth models, and FILM for computer vision techniques.
DBeam is a mature Java library and CLI tool that extracts data from SQL databases (PostgreSQL, MySQL, MariaDB, H2) and exports it as Apache Avro files, typically stored in Google Cloud Storage. It operates as a single-threaded Apache Beam pipeline, first inferring the table schema by reading one row, then streaming the full result set via JDBC directly into Avro binary encoding using a custom Beam sink. The tool supports partitioned exports, parallel query execution via a split column (experimental), multiple Avro codecs, KMS-decrypted passwords, and various array handling modes. It is designed for reliability in production batch data extraction pipelines and has been in use at Spotify since 2017. The codebase is well-tested and uses modern Java practices (AutoValue, Beam SDK 2.76), with CI/CD workflows for Maven Central releases.
This repository is the Open Source Society University (OSSU) computer science curriculum guide. It is not a software application or data pipeline; it is a curated, version-controlled list of free online courses, textbooks, and resources organized to replicate the core of an undergraduate computer science degree. The repository contains markdown files that describe the curriculum structure, course pages with instructions, and supporting documentation (FAQ, contributing guidelines, changelog). It uses Jekyll to generate a static website at cs.ossu.dev and includes a minimal GitHub Actions workflow to automatically close empty issues. The primary function is to serve as a reference and roadmap for self-learners, not to execute code or process data. While it has no reusable software components, its value lies in the careful curation and community-maintained structure.
This repository is a large-scale educational resource and community showcase for building LLM-powered agents using the custom 'HelloAgents' framework. It is organized as a multi-chapter tutorial (16 chapters) covering agent fundamentals, tool use, memory systems, multi-agent protocols (MCP/A2A/ANP), context engineering, reinforcement learning (SFT→GRPO), and evaluation. Each chapter contains runnable code examples, and the repository also hosts 40+ community-contributed 'Co-creation-projects' that demonstrate real-world agent applications across domains including stock analysis, health record management, academic research, code assistance, game design, and data analysis. The architecture is not a single deployable system but a polyglot collection of independent projects, most following a FastAPI backend + Vue/React frontend pattern, with a shared dependency on the HelloAgents framework core. The primary data flow in each project is: user input → LLM reasoning loop (ReAct/Plan-and-Solve/Reflection) → tool execution (search, database, code execution, APIs) → memory/context update → response generation. External dependencies include OpenAI-compatible LLM APIs, search engines (Tavily, Brave, DuckDuckGo), vector stores (Qdrant, Milvus, Neo4j), and various domain-specific APIs (financial data, academic databases, weather). The codebase serves as both a learning path for agent development and a practical reference for common agent patterns, though quality varies significantly between the polished tutorial chapters and the prototype-level community projects.
This repository is a curated list of awesome C++ frameworks, libraries, resources, and tools. It is not a software application or data research project; it is a markdown-based reference list organized by categories such as standard libraries, frameworks, AI, audio, compression, concurrency, cryptography, databases, GUI, machine learning, networking, and many more. The list is maintained by the community via pull requests and follows the 'awesome list' format. It serves as a comprehensive index for C++ developers seeking high-quality libraries and tools. There is no executable code, no architecture, and no data pipelines; the entire content is static documentation.
This is the largest structured Chinese classical poetry dataset on GitHub, containing ~55,000 Tang poems, ~260,000 Song poems, ~21,000 Song ci (lyric poetry), and additional classical texts (Four Books and Five Classics, Book of Songs, Chu Ci, Yuan opera, etc.). The data is distributed as JSON files organized by dynasty and genre, with each poem containing author, title, and paragraph fields. The repository serves as a foundational dataset for Chinese NLP, digital humanities, and cultural heritage projects. The codebase is minimal — essentially a data repository with a JSON validation test (test_poetry.py), a simple data loader (loader/data_loader.py), and a web scraper for Song ci (宋词/UpdateCi.py). The data itself is the product of web scraping from sources like ctext.org and other online repositories, with manual curation and error correction over time. The repository includes an 'error' directory containing records with data quality issues (corrupted characters, missing content, etc.), which demonstrates transparency about data limitations. The data loader provides a basic abstraction for extracting poem bodies across different datasets, but the overall engineering is straightforward. The value lies entirely in the data breadth and accessibility — no complex transformations, feature engineering, or analytical pipelines are present. The repository is widely used (52K+ stars) as a reference dataset for Chinese poetry generation, analysis, and educational applications.
This repository is a curated resource list (Awesome List) for Chief Technology Officers and VP R&D professionals. It contains no executable code, API endpoints, or data pipelines. The repository consists of a single README.md file with structured links to external resources organized by topic (hiring, architecture, startups, etc.), a LICENSE file (CC0), and a Jekyll theme configuration. The value proposition is entirely in the curation effort and organization of external resources, not in software craftsmanship. This is a documentation/resource aggregation project designed to be deployed as a static GitHub Pages site using Jekyll. The high star count (35K+) reflects community value in the curated content, not technical complexity.