This repository is a comprehensive, community-authored tutorial for video encoding and VapourSynth preprocessing, maintained by VCB-Studio. It is primarily documentation with executable example scripts (.vpy), covering everything from video format fundamentals to advanced mask generation and expression-based pixel manipulation. The 'Basics' section builds foundational knowledge (e.g., video properties, common artifacts, encoding tools), while the 'Advanced' section dives into VapourSynth internals like the Expr filter and mask creation. Although not a standalone application, the scripts are production-oriented and carefully crafted to illustrate best practices in Blu-ray ripping and quality enhancement. The repository is actively maintained with a responsive issue tracker, and its content reflects current industry techniques.
This repository is a comprehensive educational course titled '.NET Web API Zero to Hero' by codewithmukesh. It contains over 50 independent ASP.NET Core Web API sample projects organized into modules covering fundamentals (minimal APIs, exception handling, logging), database management with EF Core (CRUD, migrations, interceptors, soft deletes, bulk operations, pagination), advanced API patterns (CQRS with MediatR, custom dispatcher, Result pattern, mapping benchmarks), performance and caching (in-memory, Redis, HybridCache, EF second-level cache), API security (JWT, refresh tokens, role/claims/policy/permission-based authorization, API keys, CORS, rate limiting), file handling (PDF invoice generation), architecture (Clean Architecture vs Vertical Slice), observability (health checks, structured logging), and background processing. Each sample is a self-contained, runnable project with minimal setup (often using in-memory databases) and includes extensive BenchmarkDotNet performance comparisons. The code is well-structured, follows modern .NET 10 patterns, and demonstrates production-quality implementations of cross-cutting concerns like global exception handling, validation pipelines, and caching strategies. While the repo is primarily a teaching resource, many components (custom CQRS dispatcher, Result pattern, EF Core interceptors, permission-based authorization) are genuinely reusable in other projects.
This repository is a comprehensive bare-metal microcontroller programming guide, providing step-by-step examples from minimal firmware to a full embedded web server with a device dashboard. The code targets ARM Cortex-M and RISC-V microcontrollers (STM32, TI TM4C, RP2040, ESP32-C3, nRF52840, etc.) and uses only GCC, a datasheet, and the Mongoose networking library. The architecture is bare-metal, single-threaded with an event loop in the webserver step; it demonstrates direct register manipulation, interrupt handling, UART, SysTick, clock configuration, printf retargeting via newlib syscalls, CMSIS integration, and Ethernet with built-in TCP/IP (MIP). The repository also includes reusable project templates for blinky, CLI, and LittleFS filesystem. Despite being educational, the code is production-quality and follows embedded best practices such as non-blocking timers, hardware abstraction layers (hal.h), and modular startup code.
This repository is a collection of competitive programming solutions and learning resources accumulated during interview preparation for a Microsoft SWE role. It contains implementations of algorithms and data structures from platforms like LeetCode, HackerRank, CodeChef, and others, organized by problem source and topic. The repository serves as both a personal record of solved problems and a reference for common coding interview patterns. The codebase consists of standalone solution files that implement specific algorithms to solve well-defined problems. Rather than a unified application, it's an educational repository where each file represents a self-contained solution to a particular coding challenge. The solutions demonstrate various techniques including two-pointer approaches, stack-based algorithms, in-place array modifications, and thread synchronization patterns. While the repository doesn't contain a single cohesive software system, it does include several reusable algorithmic patterns that could be extracted for use in other projects. Notable examples include the stack-based parentheses validation, two-pointer technique for sorted arrays, in-place array modification algorithms, and thread coordination mechanisms using Events and Semaphores. These components represent fundamental computer science concepts implemented with attention to correctness and efficiency.
This repository is a static website for a Chinese-language educational course titled 'Deep Agents 实战' (Deep Agents in Action). It provides 16 chapters of technical content on building AI agents using LangChain and LangGraph, including text, video links, and downloadable PDFs. The site is built with Astro 6, Tailwind CSS 4, and TypeScript, and is deployed to GitHub Pages via GitHub Actions. The codebase is well-structured: content is authored in Markdown under `content/`, metadata is managed in `scripts/chapters.json`, and a preprocessing script injects frontmatter into the Astro content collection. Custom Astro components handle layout, navigation, theme toggling, and a responsive table of contents. The repository also includes CI/CD workflows for asset validation and cross-platform installation testing. While the primary purpose is educational content delivery, the build and content pipelines demonstrate reusable patterns for static site generation with Astro.
This is a Flutter package for creating step-by-step showcase/onboarding tours. It highlights widgets with tooltips, supports custom tooltip widgets, auto-play, animations, and multiple scopes. The architecture uses a service locator pattern (ShowcaseService) to manage independent showcase scopes without requiring BuildContext. The overlay system uses a custom ShapeClipper to cut out holes around target widgets. The code is well-organized and actively maintained, though it lacks unit tests.
This repository is a Spring Guide tutorial demonstrating how to build a Spring Boot web application that accepts HTTP multipart file uploads. It contains four project variants: initial and complete versions in both Java and Kotlin, each with Maven and Gradle build files. The complete version adds a FileUploadController with endpoints for listing uploaded files, serving them as downloads, and handling uploads, plus a StorageService abstraction backed by a FileSystemStorageService that writes files to a configurable local directory (default 'upload-dir'). A Thymeleaf template provides a simple HTML upload form. The application is a small monolith: Spring MVC controllers handle GET / (list files), POST / (store uploaded file), and GET /files/{filename} (download with Content-Disposition). The storage layer uses java.nio.file APIs and includes a path traversal protection check that rejects filenames escaping the root directory. Upload size limits are configured via spring.servlet.multipart properties. Tests cover controller behavior with MockMvc, storage service security cases, and full integration tests using RestTestClient with redirect handling. This is educational sample code, not a production service. It demonstrates clean separation between web layer and storage abstraction, and the complete version includes meaningful security and testing patterns that can be reused in real projects. The code is actively maintained, uses current Spring Boot 4.0.x and Java 17, and is well-suited as a reference for implementing file upload endpoints.
This repository contains the source code for a personal link-in-bio website (moure.dev) built with the Reflex Python web framework. It serves as both a live production site and a practical example for a 13-hour web development course. The application is a full-stack Python app with a static frontend (React/Reflex) and a Dockerized backend. It integrates multiple external APIs: Twitch (live status), Supabase (featured content), ConfigCat (feature flags), and Beehiiv (newsletter). The architecture follows a component-based design with reusable UI elements (link buttons, cards, navbar, footer) and a centralized state management pattern. The frontend is exported as static HTML/JS and hosted on Vercel, while the backend runs on Railway. The code is well-structured, uses modern Reflex with Radix UI, and includes deployment scripts and a GitHub Actions CI pipeline. It is primarily a learning resource and a functional personal site, not a generic library or framework.
Go by Example 中文版 is a static site generator that produces a Chinese-language tutorial website for Go programming. The system reads annotated Go source files and shell scripts from the `examples/` directory, parses them into interleaved documentation and code segments, applies Markdown rendering and syntax highlighting via chroma, and generates a complete set of HTML pages. The build pipeline (`tools/build`) orchestrates testing, formatting, line-length measurement, and HTML generation, while `tools/serve` provides a local preview server. The site is deployed to S3 using a dedicated upload script. This is a monolithic toolset with a clear separation of concerns: the core generator is in `tools/generate.go`, templates are in `templates/`, and static assets are served directly. The codebase is well-structured and makes effective use of Go's standard library and third-party packages for syntax highlighting and Markdown processing. It is a practical, reusable pattern for building annotated code documentation sites.
This repository is a comprehensive, step-by-step tutorial series for learning wgpu, the Rust implementation of WebGPU. It contains over 30 example crates organized into beginner, intermediate, compute, and showcase categories, each demonstrating a specific GPU concept (window creation, pipelines, buffers, textures, uniforms, instancing, depth, lighting, normal mapping, HDR, compute shaders, etc.). The code is production-quality Rust with extensive use of wgpu, winit, cgmath, and bytemuck. A reusable framework crate (`code/showcase/framework`) provides a `Demo` trait, camera, model/texture loading, and pipeline builders, which many showcases implement. The repository also includes a VuePress documentation site with embedded WebAssembly demos, build scripts for WASM deployment, and a demo server. While the tutorials are well-structured and educational, there is significant code duplication across crates (e.g., identical `build.rs` files, repeated initialization boilerplate), and some showcases are stale or excluded from builds. The codebase tracks wgpu API changes closely (news files document migrations from 0.12 to 30.0), but some patterns use deprecated APIs (e.g., `wgpu::Backends::PRIMARY`, `immediate_size` in pipeline layouts). Overall, it is a valuable learning resource with solid engineering practices, though not a production library.
This repository is a comprehensive Chinese-language educational tutorial and codebase for Retrieval-Augmented Generation (RAG) systems, created by Datawhale. It systematically covers the full RAG stack from fundamentals (data loading, chunking, embeddings) to advanced techniques (hybrid search, query construction, Text2SQL, reranking, agentic RAG, and Graph RAG). The code is organized by chapter, with runnable Python scripts demonstrating each concept using popular frameworks like LangChain, LlamaIndex, and LangGraph, alongside vector databases (Milvus, FAISS) and graph databases (Neo4j). While primarily an educational resource, the repository contains several well-crafted, reusable components such as a minimal Text2SQL agent framework, a clean LangGraph-based agentic RAG pattern, and a custom ColBERT reranker. The practical application is a Chinese recipe Q&A system ('尝尝咸淡'), which serves as a consistent domain for demonstrating various RAG techniques. The codebase is hybrid in nature, blending structured educational content with functional demo applications. The repository is actively maintained with a large community following. However, users should be aware of technical drift risks including vendored model code, hardcoded API dependencies, and the presence of AI-generated code sections. The core value lies in its structured curriculum and reusable RAG patterns rather than as a production-ready system.
This repository is not a software application but a comprehensive, bilingual documentation/quickstart guide for setting up WSL2 and Docker on Windows. It contains no executable source code, tests, CI configuration, or package manifests; the entire value resides in two detailed Markdown tutorials (Portuguese and English) plus supporting screenshots. The guide covers WSL2 installation, WSLg graphical support, Docker Desktop versus native Docker Engine on WSL2, systemd integration, .wslconfig and wsl.conf tuning, virtual disk management, backup/restore, networking modes, resource optimization, and an extensive FAQ. Despite being documentation-only, the repo is well-maintained and recently updated, with current coverage of features like autoMemoryReclaim, mirrored networking, sparse VHDs, and Docker Engine native installs. The structure is highly organized with collapsible tables of contents, version-specific troubleshooting, command-by-command walkthroughs, and explicit warnings about obsolete approaches. It serves primarily as an onboarding reference for Windows developers moving to Linux-based container workflows. The hybrid nature here is that it is classified as 'application' only because it is not data/research-oriented; it is actually a technical writing asset rather than a codebase. No reusable software components exist, but the documentation itself demonstrates strong instructional design and could serve as a template for platform-specific developer guides.
This repository is an educational tutorial series that teaches how to build a nanoGPT-like transformer language model from scratch using PyTorch. It consists of over 30 Jupyter notebooks (with both TODO exercises and answer keys) designed for Google Colab, covering topics from token embeddings and positional encodings to multi-head attention, transformer blocks, training loops, scaling experiments, and instruction tuning. The code is modular, with separate classes for each component (TokenEmbedding, PositionEmbedding, AttentionHead, MultiHeadAttention, FeedForward, TransformerBlock, VocabularyLogits, nanoGPT, DataLoader, Trainer, ModelConfig), making it a valuable learning resource. Training is demonstrated on the Shakespeare dataset and later on a sample of FineWeb-Edu, with experiments on model size, learning rate, and tokenization. While the repository is not a production data pipeline or deployable application, it exhibits strong data/research characteristics through its focus on model training, scaling laws, and loss analysis. The notebooks are well-structured for self-paced learning but rely on Colab-specific workflows and hardcoded data URLs, limiting portability.
This repository is an educational resource focused on teaching the Gang of Four (GoF) design patterns through comprehensive explanations, code examples, and diagrams. It covers creational, structural, and behavioral patterns, with each pattern accompanied by detailed markdown documentation, visual diagrams, and runnable code samples in both Java and Kotlin. The project structure organizes content by pattern type, making it easy to locate and study specific patterns. The code examples demonstrate practical implementations of each pattern in context-specific scenarios, such as a banking system for the Command pattern, a notification system for the Decorator pattern, and a file system for the Composite pattern. While the build configuration defaults to running a Singleton demo, each pattern includes independent main functions or demo classes that can be executed separately. The repository also features automated workflows for building and deploying the documentation via GitHub Pages. Despite some maintenance challenges like duplicate documentation files (marked for removal in a future version) and the coexistence of Java and Kotlin examples, the project shows active maintenance through contribution guidelines, regular updates, and a clear migration path toward consolidating documentation. The examples are well-crafted, self-contained, and illustrate core object-oriented design principles effectively, making them valuable for both learning and reference purposes.
This repository is the Korean translation of the Modern JavaScript Tutorial (https://javascript.info). It contains a comprehensive collection of educational articles, tasks, solutions, and interactive code examples covering core JavaScript, browser APIs, networking, animations, web components, and regular expressions. The content is structured as static markdown files with embedded code snippets and self-contained HTML demos. It is not a production software application but a static educational resource. The repository demonstrates consistent translation conventions and includes reusable teaching patterns such as decorators, custom events, drag-and-drop algorithms, and event delegation. Some content references older browser behaviors and deprecated APIs (e.g., `__proto__`, XMLHttpRequest), but also covers modern features like async/await, Promises, and modules. The code examples are clean and well-documented, making it a valuable learning resource for Korean-speaking developers.
This repository is an educational tutorial for Apache Spark using Scala, designed to teach distributed data processing concepts through practical examples. It functions as a data research and engineering learning resource, featuring Jupyter notebooks and Scala source code that demonstrate RDD operations, SparkSQL, and streaming pipelines. The project includes bundled datasets such as the King James Version Bible and the Enron Spam/Ham email corpus, along with golden output files for test verification. While it serves as a comprehensive guide for Spark development, it primarily focuses on teaching data transformation patterns rather than deploying a production service. The codebase demonstrates solid engineering practices for an educational context, including unit tests, custom utility classes for CLI argument parsing, and structured data schemas. However, the technical stack is significantly outdated, relying on Spark 2.3.0 and Scala 2.11.8, which are no longer supported. The examples frequently use deprecated APIs, such as the RDD-based DStream for streaming, which has been superseded by Structured Streaming in modern Spark versions. This creates a high technical drift, making the code less suitable for new projects without significant refactoring. Despite the outdated dependencies, the repository remains a valuable resource for understanding Spark fundamentals. The inclusion of golden files and test utilities provides a reproducible framework for validating data processing logic. The tutorial structure progresses logically from basic word counts to complex SQL and streaming operations, making it effective for learning. Users should be aware that while the patterns are sound, the specific API implementations will require updates to align with current Spark LTS versions.
This is a monorepo containing starter templates and final code for the official Next.js Learn courses. It includes multiple independent Next.js applications demonstrating the Pages Router, App Router, data fetching, authentication, SEO optimization, and more. The code is educational, well-structured, and follows modern Next.js patterns (server actions, streaming, suspense, etc.). It is not a production application but serves as a reference implementation for learning. The dashboard example includes a full CRUD invoice management system with PostgreSQL, NextAuth authentication, and Tailwind CSS styling. The basics examples cover static generation, dynamic routes, API routes, and TypeScript. The SEO example demonstrates performance optimization techniques like dynamic imports and lazy loading.
This repository contains the official source for 'The Swift Programming Language' (TSPL) book, published at docs.swift.org. It is a documentation project, not a running application. The primary content is a set of Markdown files organized as a DocC documentation catalog, covering language guides, reference manuals, and a guided tour. The repository also includes build scripts (e.g., bin/publish-book, bin/add-beta-banners, bin/generate-grammar) and a legacy URL redirect infrastructure (bin/redirects/). The system's 'production' output is a static HTML website generated by Swift-DocC. The architecture is a standard documentation pipeline: source markdown → DocC conversion → deployment. The repository is actively maintained and tightly coupled to the Swift compiler's evolution, meaning documentation drifts only when the language changes. The code present (build scripts, redirect generator) is functional but not architecturally exceptional; the true value is in the documentation content itself.
This repository is the companion code for the O'Reilly book 'Hands-On Large Language Models' by Jay Alammar and Maarten Grootendorst. It provides 12 chapters of Jupyter notebooks covering fundamental and advanced LLM topics including tokenization, embeddings, text classification, clustering, prompt engineering, semantic search, multimodal models, fine-tuning, and generation. All notebooks are designed to run on Google Colab with free GPU resources and rely heavily on Hugging Face libraries (transformers, datasets, sentence-transformers, TRL) and external APIs (OpenAI, Cohere). The code is educational in nature, with clear step-by-step explanations and visualizations. While it is not a production application or a novel research pipeline, it serves as a high-quality, reproducible tutorial resource for practitioners learning LLM workflows. The repository includes pinned dependencies, Conda environment setup, and local installation guides, making it relatively easy to reproduce in a controlled environment, though API keys are required for some sections.
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.