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 comprehensive collection of React interview questions and coding exercises, designed as an educational resource for developers preparing for React interviews. It contains over a dozen standalone React projects built with modern tooling (Vite, TypeScript, React 19), each demonstrating a specific UI pattern or hook implementation. The codebase is well-organized into three main sections: a coding-exercise app with a registry pattern for interactive problem-solving, a coding-hooks library of reusable custom hooks (useDebounce, useFetch, useLocalStorage, etc.), and a set of coding-projects (accordion, autocomplete, carousel, data table, infinite scroll, modal, nested comments, shopping cart, star rating, theme switcher, todo, tree view). The projects are cleanly implemented with TypeScript, proper state management, and accessibility considerations. While primarily educational, the custom hooks and several UI components are production-quality and directly reusable in other projects.
This repository is a comprehensive Chinese-language Rust tutorial titled 'Rust Course' (Rust 语言圣经). It is primarily an educational documentation project built with mdBook, producing a static website and a PDF. The content covers Rust from basic syntax to advanced topics like async, unsafe, concurrency, and performance optimization, with over 170 chapters and 1.1 million characters. It also includes a forked and translated version of the rustlings interactive exercise system (rustlings-zh), which provides a CLI tool for hands-on practice. The repository is not a production application but a learning resource; however, the rustlings-zh component is a functional CLI application. The architecture is a static site generator (mdBook) plus a standalone Rust CLI tool. Key entry points are the mdBook configuration (book.toml) and the rustlings-zh main.rs. The project is well-maintained, tracks Rust versions up to 1.89, and has active community contributions.
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.
TheAlgorithms/Java is a comprehensive, community-maintained collection of over 600 algorithm and data structure implementations in Java, organized into topic-specific packages (e.g., maths, sorts, searches, dynamic programming, graph, ciphers, compression, machine learning, streaming). It is designed as an educational reference library, not a production application. The architecture follows a modular utility-class pattern: most algorithms are implemented as final classes with private constructors and static methods, and many implement shared interfaces such as SortAlgorithm and SearchAlgorithm for polymorphic usage. The codebase includes extensive JUnit 5 test coverage with parameterized tests, and many classes reference Wikipedia or academic sources. While the overall quality is high with many reusable components, there are some inconsistencies such as duplicate implementations, leftover main methods, and occasional use of raw types or legacy APIs. The repository is actively maintained with CI workflows, dependabot, and a structured contribution process.
This repository provides a minimal, from-scratch implementation of a Vision-Language Model (VLM) called MiniMind-V, designed for educational purposes and low-resource training. It ingests the ALLaVA-4V dataset (Parquet format with image bytes and JSON conversations) for pretraining (1.27M caption pairs) and supervised fine-tuning (2.9M mixed instruct/caption/text). The architecture follows a LLaVA-1.5 style: a frozen SigLIP2 visual encoder (256×256, 64 patch tokens) projects via a 2-layer MLP into a MiniMind LLM (with optional Mixture-of-Experts). Training freezes the visual encoder and trains only the projector and selected LLM layers, achieving ~3 RMB / 2 hours on a single RTX 3090. The codebase includes training scripts (pretrain and SFT), evaluation, a Gradio web demo, and model conversion to HuggingFace Transformers format. While primarily a research/educational project, it demonstrates a clean, modular VLM pipeline that can be adapted for other multimodal tasks.
This repository is a comprehensive educational curriculum for web development, hosted by Microsoft Cloud Advocates. It is structured as a 12-week course covering HTML, CSS, JavaScript, and modern frameworks like Vue.js and Next.js. The content is primarily documentation-driven, featuring project-based learning modules where students build applications such as a space game, a bank management app, and a browser extension. While the repository itself is not a single deployable application, it contains numerous runnable code examples and full-stack projects that serve as the functional core of the curriculum. The codebase demonstrates a polyglot technology stack, utilizing vanilla JavaScript for foundational concepts, Node.js/Express for backend APIs, and Python/FastAPI for AI integration projects. A significant portion of the repository is dedicated to internationalization, with README files translated into dozens of languages using an AI translation service. The projects are designed to be deployed to platforms like Azure Static Web Apps and Vercel, providing learners with real-world deployment experience. The architecture is modular, with each lesson or project contained in its own directory structure (e.g., `6-space-game`, `7-bank-project`). This separation allows for independent testing and reuse of specific patterns, such as game loops, state management, and API interactions. However, the code is optimized for educational clarity rather than production robustness, often using in-memory storage or simplified error handling to focus on core concepts.
This repository is a comprehensive collection of annotated PyTorch implementations of deep learning papers, spanning transformers, GANs, reinforcement learning, diffusion models, and more. Each implementation includes side-by-side notes explaining the code and underlying concepts, making it an educational resource for understanding and reproducing paper results. The codebase is organized by paper/model type, with standalone experiment scripts, reusable modules, and configuration-driven training loops. Key strengths include clean abstractions for transformer components, a flexible configs system, and extensive coverage of both foundational and modern architectures. However, the project has not seen commits since early 2024, some dependencies are outdated, and certain experiments require large GPU resources or external data not bundled in the repo. While individual components are well-crafted and reusable, the overall collection is best used as a reference and learning tool rather than a production framework.
This repository is a comprehensive Python tutorial (28k+ stars) covering beginner to advanced topics, with content written in Markdown and published as a static documentation site via MkDocs. The codebase includes a custom tool (`tools/example_runner.py`) that extracts and executes Python code blocks from the Markdown files to verify correctness, integrated into CI. The project also uses modern Python tooling (uv, ruff, pytest) and provides an interactive learning site at learn-py.org. While primarily educational content, the repository demonstrates solid engineering practices with automated testing of examples, dependency management, and CI/CD pipelines.
This repository provides educational materials for a hands-on course on building a RISC-V CPU core from scratch. The core is implemented in Transaction-Level Verilog (TL-Verilog) and is designed to run on the Makerchip online IDE. The repository contains a starting-point shell (risc-v_shell.tlv) with a simple test program that sums 1 to 9, and a reference solutions file (risc-v_solutions.tlv) that hides the full implementation. The library (lib/risc-v_shell_lib.tlv) includes reusable, parameterized components such as a register file, data memory, instruction decoder, ALU, and a sophisticated CPU visualization module. The code is modular, uses M4 macros for assembly and configuration, and is well-structured for educational purposes. While the repository is not a standalone application, it effectively demonstrates digital logic design and CPU microarchitecture concepts in a simulation environment.
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.
This repository is an extensive, open-source educational tutorial on building and training large language models (LLMs) from scratch, maintained by the Datawhale community. It covers the full pipeline: NLP fundamentals, Transformer architecture (with a custom Tiny-K implementation), pretraining, supervised fine-tuning (SFT), parameter-efficient fine-tuning (LoRA), reinforcement learning (GRPO, OPD, Search-R1, ReTool), and practical applications like RAG and Agent systems. The code is organized into chapters with clear progression, and each chapter includes runnable scripts, configuration files, and detailed documentation in Chinese. While primarily educational, the repository contains several well-crafted, reusable components such as a modular Transformer implementation, efficient dataset loaders, a RAG pipeline, an Agent framework, and RL training loops with distributed support. The project is actively maintained with recent additions (Extra-Chapter) and has a large community following. However, reproducibility is moderate due to fragmented dependency files, hardcoded paths, and reliance on external services (e.g., DeepSeek Search, SwanLab). The code is not production-grade but serves as an excellent learning resource and a source of reusable patterns for LLM research and development.
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.
This repository is a comprehensive collection of algorithm tutorials and solutions primarily based on LeetCode problems. It contains over 60 original articles covering various algorithm techniques and data structures, with solutions implemented in multiple programming languages including Java, Python, C++, JavaScript, and Go. The content is organized into thematic series covering dynamic programming, data structures, algorithm thinking patterns, and high-frequency interview questions. The repository serves as an educational resource for algorithm learning, providing detailed explanations of problem-solving frameworks and reusable code patterns. Each article typically includes problem descriptions, solution approaches with step-by-step reasoning, complete code implementations, complexity analysis, and links to related practice problems. The content emphasizes teaching algorithmic thinking patterns rather than just providing solutions. The codebase demonstrates solid educational value with well-structured explanations and reusable algorithm templates. However, as a documentation and education-focused project rather than a software application, it lacks traditional software engineering elements like dependency management, testing frameworks, or reproducible execution environments. The code snippets are designed for algorithm learning rather than production use.
This repository is a community-maintained study hub for the GATE Data Science and Artificial Intelligence (DA) exam. It provides syllabus-aligned resources including detailed markdown guides for seven core subjects (Probability & Statistics, Linear Algebra, Calculus & Optimization, Programming & Algorithms, Database Management, Machine Learning, Artificial Intelligence), verified previous-year question papers (2024–2026) with checksums, and focused Jupyter notebooks for practice. The primary delivery mechanism is a Flask web application that renders the markdown guides into an interactive curriculum explorer with topic checklists, progress tracking, presentation mode, and a radial memory map. The webapp can be exported as a static site for GitHub Pages deployment, and a CI/CD pipeline (GitHub Actions) runs tests, link audits, and checksum verification on each push. The repository also includes link validation scripts for pull requests and a set of deterministic example notebooks generated programmatically. While the core is an application, it also contains research-like elements such as exam pattern analysis, stale-link audits, and educational notebooks, but these are secondary to the main purpose of providing a structured, browsable study resource.
This repository is a Next.js static site that serves as the companion website for the 'Complete Intro to Web Dev v3' course by Brian Holt. It renders lesson content from Markdown files, provides interactive code editors via Klipse, and includes navigation between lessons. The architecture is a standard Next.js application with static generation at build time. The codebase is well-organized with clear separation of concerns: data loading logic in `data/lesson.js`, layout components in `components/`, and page routing in `pages/`. While the site is tailored to this specific course, the lesson loading module is a reusable pattern that could be extracted for other course sites. The project is actively maintained with recent commits and a CI/CD pipeline for deployment to GitHub Pages.
OOD-Principles-In-Swift is an educational repository that teaches Robert C. Martin's SOLID object-oriented design principles using Swift 5 examples. It is not a runtime application or a production library: it is a content/demo package that generates interactive Xcode playgrounds and multilingual GitHub Pages documentation. The canonical code lives in source/SOLID/*.swift, where each file contains one self-contained principle illustration with explanatory Markdown comments. Bash scripts named generate-playground-*.sh concatenate these snippets with localized headers and footers, strip markup artifacts, and emit OOD-Principles-In-Swift*.playground/contents.swift plus README-*.md for a dozen languages. When consumed, the primary entry point is OOD-Principles-In-Swift.playground/contents.swift, which renders five SOLID sections in Xcode's playground UI. The repo also acts as a Jekyll site via _config.yml and _layouts/default.html, hosting the translated READMEs on GitHub Pages. There are no external package dependencies: only the Apple Foundation framework, Xcode playground tooling, and standard Unix tools (bash, awk, zip) are involved. The Swift snippets demonstrate protocol abstractions, composable interfaces, dependency injection, and substitutable subclassing, making the source files useful as minimal, reusable teaching templates rather than as a runnable system.
TheAlgorithms/JavaScript is an extensive open-source collection of over 700 algorithm and data structure implementations in JavaScript, designed for educational purposes. It covers a wide range of categories including sorting, searching, dynamic programming, graph algorithms, cryptography, math, string manipulation, and more. Each algorithm is implemented as a standalone module with corresponding tests, following ES module syntax. While primarily a learning resource, several components like caching classes (LRU, LFU), memoization utilities, and classic data structures (binary heap, AVL tree, Trie) demonstrate high-quality, reusable patterns. The repository employs CI/CD, linting, and automatic directory updates, ensuring code consistency. However, some modules exhibit minor issues such as DOM dependencies in Node context and duplicate implementations, reflecting the community-contributed nature of the project.
This repository is a comprehensive, educational collection of 42+ Jupyter notebooks and runnable scripts demonstrating a wide array of Retrieval-Augmented Generation (RAG) techniques. It is primarily a data_research and educational resource, not a deployable application or library. The codebase serves as a practical cookbook for engineers and researchers, covering the full RAG stack from basic chunking and retrieval (e.g., simple RAG, BM25) to advanced methods like GraphRAG, Self-RAG, HyDE, RAPTOR, and agentic RAG. It also includes a dedicated evaluation framework with notebooks and reusable scripts for measuring faithfulness, relevance, and correctness using tools like DeepEval and custom LLM judges. The architecture is modular, with a shared helper_functions.py providing common utilities for PDF loading, embedding, and retrieval, and an evaluation/ module offering reusable evaluation pipelines. The runnable scripts in all_rag_techniques_runnable_scripts/ provide cleaner, class-based implementations of the techniques that are more suitable for integration into other projects than the notebooks themselves. While the code is well-structured for an educational project and demonstrates high craftsmanship in its reusable components, it is not designed for production deployment. Reproducibility is limited by the lack of a pinned dependency file and reliance on external API keys. The repository is actively maintained and highly influential (29k+ stars), making it a valuable reference for anyone building or evaluating RAG systems.