This repository serves as the primary source for .NET documentation (learn.microsoft.com/dotnet). It contains conceptual guides, API references, and runnable code samples demonstrating .NET language features, frameworks, and best practices. The repository is not a single application but a curated collection of educational materials organized by technology domain (e.g., C#, ASP.NET Core, Orleans, AI). Code samples illustrate patterns like dependency injection, logging, serialization, and data access, often with minimal, self-contained examples. Maintenance is active via GitHub Actions workflows for linting, dependency updates, and version sweeping, ensuring content stays current with .NET releases.
Rustlings is an interactive CLI application designed to teach Rust through a series of small, hands-on exercises. It provides a terminal-based learning environment where users edit, compile, test, and run Rust code snippets, progressing through topics from basic variables to async programming. The system is built as a single binary that embeds all exercise files and solutions at compile time using a custom proc macro, eliminating external file dependencies. The CLI offers multiple modes: a watch mode that automatically re-checks exercises on file changes, a list mode for browsing and selecting exercises, and commands for running, hinting, resetting, and checking all exercises. State persistence tracks user progress in a local file. The architecture is modular, with clear separation between exercise execution logic, terminal UI, state management, and developer tooling. External dependencies include clap for argument parsing, crossterm for terminal control, notify for file watching, and serde for serialization. The project is actively maintained by the Rust community and serves as the official companion to 'The Rust Programming Language' book.
This repository is a comprehensive, hands-on Rust course consisting of ~100 exercises that progressively teach Rust's core concepts, from basic syntax and ownership to concurrency and async programming. It is structured as a monorepo with a book (mdbook) and a set of exercise crates, each with its own tests. The code is well-crafted, demonstrating idiomatic Rust patterns such as newtypes with validation, error handling via thiserror, and safe concurrency with channels and locks. While not a production application, the exercises serve as a high-quality reference for Rust best practices and are actively maintained by Mainmatter.
This repository is the source code and build toolchain for the Go by Example website (https://gobyexample.com), an educational tutorial for the Go programming language (a concurrent, channel-based language). The site teaches Go through annotated example programs. The repository contains example source files (Go code with embedded documentation), a set of command-line tools written in Go that parse these examples, render them into HTML using templates, and output a static site. The build pipeline includes syntax highlighting via chroma, Markdown rendering via blackfriday, and deployment to S3. The project also includes a local preview server, a line length enforcer, and CI/CD via GitHub Actions that regenerates the site and diffs against the committed output to ensure consistency. The architecture is a collection of focused Go tools (generate, serve, upload, measure, test) orchestrated by shell scripts. The codebase demonstrates clean separation of concerns, template-driven HTML generation, and a custom lexer for shell output formatting.
This repository is a comprehensive tutorial on building AI agent harnesses, structured as 17 progressive lessons. Each lesson introduces a single mechanism (tool use, permissions, hooks, planning, subagents, skill loading, context compaction, memory, task system, background tasks, cron scheduler, agent teams, MCP integration, workflow runtime, and goal loop) that extends a core agent loop without modifying it. The harness enables a language model (Claude) to perceive, reason, and act through tool interactions while managing context, permissions, and collaboration. The repository includes runnable Python implementations for each lesson and an interactive Next.js web application with visualizations for learning and experimentation.
This repository is a comprehensive educational course titled 'AI Agents for Beginners', structured as a collection of Jupyter notebooks and code samples. It functions primarily as an ML notebook collection and tutorial suite rather than a deployable application or library. The content focuses on teaching the Microsoft Agent Framework (MAF) and Azure AI ecosystem, covering topics from basic agent concepts to advanced protocols like MCP and A2A. The codebase is organized into 18 lessons, each containing Python and .NET code samples, documentation, and images. It relies heavily on external cloud services (Azure AI Foundry, Azure OpenAI) and rapidly evolving AI standards, making it a high-quality learning resource but one with significant dependency volatility.
This repository is a bilingual (Chinese/English) open-content book titled 'Life Level-up Guide' (人生进阶指南), focused on lifelong learning, English acquisition, AI collaboration, personal development, and evidence-based growth. It is published as a VitePress static documentation site with deterministic EPUB and PDF exports. The codebase includes a sophisticated build toolchain with content validation, navigation synchronization, accessibility enhancements, and extensive Playwright end-to-end tests. While not a traditional software application, it demonstrates high craftsmanship in content management, automated publishing, and quality assurance. The repository is actively maintained with CI/CD pipelines, link auditing, and bilingual parity enforcement.
This is a comprehensive educational website and tutorial series for WebGPU, the next-generation graphics API. It provides over 100 interactive lessons covering fundamentals, 3D math, lighting, textures, compute shaders, post-processing, and more. The site is built as a static site with a custom build system, featuring live code editors, interactive diagrams, and multilingual support. The codebase includes reusable WebGPU utilities, a diagram framework, and helper libraries for timing, texture loading, and shader reflection. It serves as both a learning resource and a reference for WebGPU developers.
This repository is a comprehensive, Jekyll-based static site serving as the official tutorial for OpenClaw, an open-source AI agent gateway. It provides a structured, multi-chapter guide (15 chapters + 15 appendices) covering installation, configuration, multi-platform integration (Feishu, WeChat, DingTalk, etc.), automation, and practical use cases for building AI agents. The site includes a polished UX with dark/light mode, scroll-spy navigation, reading progress bar, and a full-text search index. Beyond documentation, the repo contains a substantial collection of automation scripts (markdown-to-docx conversion, image uploading, CSDN auto-publishing, formatting fixes), example skills (JavaScript templates for custom skills), configuration templates (multi-agent, multi-model, Feishu integration), and GitHub Actions for CI/CD (Jekyll build, issue processing, content sync). The repository is actively maintained, with a clear version baseline (v2026.6.8) and frequent updates. While primarily a documentation project, the inclusion of reusable scripts, skill templates, and a well-crafted Jekyll layout makes it valuable for developers building similar documentation sites or OpenClaw-adjacent tools. The hybrid nature is evident: it serves as both a reference manual and a toolkit of reusable components for the OpenClaw ecosystem.
vimhjkl is a Vim technique trainer that drills advanced Vim skills (dot command, text objects, registers, macros, Ex commands) using real vim/nvim as a subprocess. It features a CLI with interactive menu (j/k navigation, vim-style counts) and four practice modes: Learn, Blind, Practice, Grind, and Review. The application uses a spaced repetition system (Leitner boxes) to schedule skill reviews based on keystroke efficiency. It includes 66 skills across 230 challenges, with a curriculum defined in JSON and generated by a separate build system. The codebase is pure Python stdlib with zero third-party dependencies, and supports internationalization (Chinese shipped) with an AI translation pipeline. The architecture is modular: CLI entry point, engine for session logic, grader for vim subprocess management, store for progress persistence, and TUI for terminal rendering. The repository also contains build scripts for curriculum generation and packaging (Homebrew, AUR).
This repository is a structured, comprehensive AI engineering curriculum spanning 20 phases and over 500 lessons, from math foundations and ML fundamentals to deep learning, computer vision, NLP, speech, transformers, generative AI, reinforcement learning, LLMs from scratch, agent engineering, multi-agent systems, production infrastructure, and ethics/safety. It is an educational resource, not a production application or data research project. The code consists of self-contained pedagogical implementations (primarily Python, with some TypeScript, Rust, and Julia) that demonstrate core algorithms from scratch—such as attention mechanisms, BPE tokenization, diffusion models, RLHF, and agent loops—using synthetic data and deterministic stubs. Capstone projects include small web servers (Hono/TypeScript) and test harnesses. The curriculum is actively maintained with CI tooling, certification prep materials, and translation support. While the code is simplified for learning, it exhibits clean patterns, consistent lesson structure, and testing practices that make individual components (e.g., tool registries, state machines, evaluation harnesses) reusable in other contexts.
This repository is a comprehensive educational guide for Claude Code, an AI coding assistant by Anthropic. It provides copy-paste templates, Mermaid architecture diagrams, and progressive learning modules covering all Claude Code features: slash commands, memory, skills, subagents, MCP, hooks, plugins, checkpoints, advanced features, and CLI usage. The repo also includes production-ready build/validation scripts (EPUB builder, static site generator, link checker, Mermaid syntax checker), multi-language translations (Vietnamese, Japanese, Chinese, Ukrainian), CI/CD workflows, and a design system. It is not a software application itself but a knowledge base with supporting tooling. The architecture is a static documentation site with Python helper scripts and pre-commit hooks. Key entry points are the CLAUDE.md project overview and the numbered module directories (01-10). The repository is actively maintained with frequent updates tracking Claude Code releases.
This repository provides a comprehensive baseline for person/object re-identification (ReID) using PyTorch. It implements a standard pipeline: data preparation (reorganizing images by identity), training with various backbones (ResNet, DenseNet, Swin, HRNet, etc.) and losses (cross-entropy, triplet, circle, contrastive, etc.), feature extraction, and evaluation (Rank-k, mAP). It also includes re-ranking (CPU and GPU-accelerated via custom CUDA kernels) and adversarial training. The code is well-structured and modular, with many self-contained loss functions and augmentation modules that can be reused in other metric learning projects. However, it is research-oriented: paths are hardcoded, dependencies are not fully pinned, and there is no containerized environment. The repository is actively maintained with support for modern architectures and PyTorch features.
This repository is an educational resource that accompanies the 'Understanding Gradle' video series. It contains a series of self-contained example Gradle projects, each demonstrating a specific concept of the Gradle build tool, from basic settings files to advanced topics like artifact transforms and Java module path. The examples are structured as independent projects with their own build configurations, often using composite builds and convention plugins to illustrate best practices. The code is well-crafted, following modern Gradle patterns (Kotlin DSL, lazy configuration, variant-aware dependency management). While not a production application, the repository serves as a reference implementation for Gradle best practices and provides reusable patterns for structuring real-world Gradle projects. The architecture is a collection of example projects, each with a my-build-logic directory containing reusable convention plugins, and a my-project directory demonstrating the concept. The examples cover the full spectrum of Gradle functionality, from settings files to CI integration.
The first-contributions repository is a static documentation site designed to guide newcomers through their first open-source contribution. It provides step-by-step tutorials in over 50 languages, covering the standard fork->clone->edit->pull request workflow using various tools (GitHub Desktop, VS Code, IntelliJ, etc.) and advanced Git scenarios. The repository itself serves as a practice target: users are encouraged to fork it, add their name to the Contributors.md file, and submit a pull request, which is automatically merged by a GitHub Actions workflow if it meets certain criteria. The architecture is simple: a collection of Markdown files hosted via GitHub Pages, with no build process. Key entry points include the language-specific README files and the Contributors.md file. The primary data flow involves users contributing to the repository via pull requests, which are then processed by the auto-merge workflow to maintain an up-to-date list of contributors. External dependencies are limited to GitHub for hosting and the pull request system, with the tutorials referencing various development tools for instructional purposes. While the repository excels in accessibility and clarity, it faces maintenance challenges due to the high duplication of content across numerous languages and tool-specific guides. Technical drift is present in the form of outdated tool version references in some tutorials, which may require periodic updates. Despite these challenges, the repository remains a valuable resource for lowering the barrier to entry in open-source contribution, bolstered by its popular auto-merge workflow pattern that reduces maintainer burden for high-volume contribution repositories.
This is the official repository for The Modern JavaScript Tutorial (javascript.info). It is primarily an educational resource containing structured articles, code examples, and interactive exercises covering JavaScript fundamentals, browser APIs, network, animations, and more. The codebase is not a software application but a collection of teaching materials. The code examples are well-crafted, demonstrate modern practices, and include patterns like throttling, debouncing, promise-based helpers, custom elements, and event delegation. While the examples are tightly coupled to the tutorial context, several utility functions (e.g., cookie helpers, animation timing functions) are self-contained and could be extracted for reuse. The repository follows a logical chapter hierarchy and includes solution views with test files. It is actively maintained with recent updates reflecting current JavaScript standards.
This repository contains the source code and assets for ActionRoguelike, a roguelike action game built with Unreal Engine 5. The game features procedural enemy spawning, a variety of player actions (such as dashing, magic projectiles, and parrying), and performance-optimized systems for managing actors and significance. The codebase is organized into modular subsystems, including AI, action systems, core game mechanics, player controls, and UI. The architecture follows Unreal Engine best practices, with clear separation of concerns. Notable reusable systems include a custom action system that allows developers to define and manage player abilities, and an actor pooling subsystem that optimizes performance by reusing instances of frequently spawned objects. The project also implements a save system for persisting game state and a significance system to prioritize updates for important actors. While the project is tailored to a specific roguelike game, several of its systems are designed with reusability in mind. The ActionSystem and Performance modules, in particular, could be extracted and adapted for use in other Unreal Engine projects with minimal modification. The recent commit activity indicates active maintenance, and the use of a recent Unreal Engine version suggests low technical drift. Overall, the codebase demonstrates solid engineering practices and provides a foundation for learning and building similar action-oriented games in Unreal Engine.
This repository is a comprehensive collection of iOS demonstration projects covering design patterns, data structures, Swift language features, iOS frameworks, and software engineering principles. Each demo is a self-contained Xcode project or Swift playground that illustrates a specific concept through working code. The collection serves as an educational resource for iOS developers learning various aspects of iOS development, from basic Swift syntax to advanced frameworks like Core Animation and Combine. While individual demos vary in complexity and polish, they collectively provide valuable reference implementations of common iOS development patterns.
This repository is a comprehensive, in-progress book titled 'Linux insides' that explains Linux kernel internals through detailed, code-driven tutorials. It is not a traditional software application but a documentation project with supporting scripts for building, validating, and exporting the book. The content covers boot process, initialization, interrupts, system calls, memory management, synchronization, timers, cgroups, and more, with extensive references to actual kernel source code. The project includes a Makefile, Dockerfile, and CI/CD workflows for automated checks and ebook generation. While the primary deliverable is educational material, the repository contains reusable scripts for code snippet validation and LaTeX PDF generation that can be extracted for other documentation projects.
This repository is the source code for the webgl2fundamentals.org educational website, a comprehensive, multi-language tutorial series for WebGL2. It is not a standalone application or library, but a static site built from markdown lessons and hundreds of interactive HTML/JavaScript example pages. The code includes reusable utility libraries for matrix math (m4.js, 3d-math.js), WebGL boilerplate (webgl-utils.js), lesson helpers, and a sophisticated interactive WebGL state diagram tool. The build system uses Grunt and custom lesson builders to generate the site. While the core educational content is well-maintained and pedagogically sound, the repository contains some legacy code (tdl library, old jQuery plugins) and many partially translated lessons, indicating ongoing maintenance but with some technical debt.