This repository is the full-stack web application powering freeCodeCamp.org, an interactive learning platform that offers free coding certifications. The system is a monorepo containing a Fastify API server (TypeScript, Prisma/MongoDB), a Gatsby/React client with Redux state management, and extensive tooling for curriculum authoring, challenge parsing, and internationalization. Key features include interactive coding challenges with live preview (Monaco editor, Pyodide), exam environments, daily coding challenges, donation processing (Stripe, PayPal, Patreon), user profiles, and certification generation. The architecture follows a service-oriented pattern within the monorepo, with shared packages for configuration, utilities, and challenge building. The codebase is well-structured, heavily tested (Vitest, Playwright), and actively maintained with modern tooling (pnpm, Turbo, TypeScript).
p5.js is a JavaScript library for creative coding, providing a comprehensive API for 2D/3D graphics, animation, interaction, and data visualization. It is designed for artists, designers, and educators, with a focus on accessibility and beginner-friendly error messages. The architecture is modular: a core module registers addons for color, shape, WebGL, DOM, I/O, math, and more. It supports multiple renderers (2D canvas, WebGL 3D, experimental WebGPU) and includes a sophisticated shader compilation pipeline (strands) that transpiles a p5.js-like DSL to GLSL/WGSL. The codebase is well-structured with extensive unit and visual regression tests, and it follows a consistent addon registration pattern for extensibility.
Wonderous is a cross-platform Flutter application that serves as an interactive educational showcase of the New7Wonders of the World. It provides richly animated editorial content (history, construction, location), photo galleries, artifact browsing with search (using pre-loaded data from the Metropolitan Museum of Art), a timeline of historical events, and a gamified collectible discovery system. The app features custom layered illustrations for each wonder with parallax effects, an iOS widget showing collection progress, and support for multiple platforms including Android, iOS, Web, macOS, and Windows. Architecturally, it is a monolithic client-side application using GetIt for dependency injection, GoRouter for navigation, and custom state management with ValueNotifier/ChangeNotifier. All data is either hardcoded in Dart files or fetched from external APIs (MET Museum, Unsplash) with self-hosted image caching. The codebase is notable for its high craftsmanship in UI animations, a consistent design system, and several reusable widget patterns that could be extracted for other projects.
This repository defines a reusable AI agent skill for role-playing as Zhang Xuefeng, a Chinese education influencer. The core artifact is SKILL.md, a meticulously crafted markdown file with YAML frontmatter that encodes five mental models, eight decision heuristics, a complete expression DNA, and an agentic workflow (research → analyze → respond). It is not a running service or library; it is a configuration file consumed by compatible agent runtimes (Claude Code, Codex, Cursor, etc.) to transform the agent's behavior. The repository also includes six research files (references/research/) that document the persona's writings, conversations, expression style, external views, decisions, and timeline, serving as the evidence base for the skill. The skill demonstrates advanced prompt engineering, cognitive modeling, and agentic protocol design, making it a high-quality example of the Agent Skills pattern. It is actively maintained and has no technical drift as it consists solely of static markdown files.
This repository is an educational library providing implementations of fundamental data structures and algorithms in JavaScript and TypeScript. It covers arrays, stacks, queues, linked lists, sets, dictionaries/hash tables, trees (BST, AVL, Red-Black, Fenwick, Segment), heaps, tries, and graphs, along with associated algorithms (sorting, searching, graph traversals, shortest paths, minimum spanning trees). The code is well-structured, generic, and thoroughly tested with Jest. Each data structure and algorithm is presented as an independent module, making it easy to study or reuse. The TypeScript versions include type annotations and complexity documentation. While primarily a learning resource, the implementations are production-quality and can be extracted for use in other projects.
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 collection of educational Python programs and Jupyter notebooks by Peter Norvig, focused on algorithmic problem-solving, puzzle-solving, and data analysis. It is not a deployable application or a formal research pipeline, but rather a set of self-contained explorations that demonstrate a wide range of programming techniques: constraint propagation, recursive search, dynamic programming, Monte Carlo simulation, n-gram language models, and symbolic computation. The code is well-structured, clearly documented, and often includes inline tests and performance benchmarks. While each notebook or script is independent, many contain reusable utility functions and algorithmic patterns that could be extracted for other projects. The repository includes data files (word lists, n-gram counts, bike ride logs, Sudoku puzzles) that are used as inputs for the explorations. The primary value is educational: it teaches how to think algorithmically and write clean, efficient Python code.
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 official companion code for the book *Build a Large Language Model (From Scratch)* by Sebastian Raschka (105k+ stars). It provides a step-by-step, educational implementation of GPT-2 and its modern variants (Llama 3, Qwen3, Gemma 3/4, Olmo3) entirely in PyTorch, organized by book chapters (2–7 plus appendices). The codebase is a mix of Jupyter notebooks for interactive learning and Python modules that form a reusable pip package (`llms-from-scratch`), accompanied by extensive CI/CD pipelines, unit tests, and performance analysis scripts. Architecturally, the core is a modular transformer library that includes tokenization (BPE, tiktoken, custom), multi-head attention with multiple variants (GQA, MLA, SWA, DSA, cross-layer KV sharing), feedforward blocks, normalization (LayerNorm, RMSNorm), and LoRA. The code supports pretraining from scratch, classification finetuning (spam, IMDB), instruction finetuning (with/without LoRA), and preference tuning (DPO). It can load pretrained weights from OpenAI, Hugging Face, and local checkpoints. The package exposes clean interfaces (`GPTModel`, `generate`, `train_model_simple`) and includes bonus materials for KV cache implementations, mixture-of-experts, memory estimators, and user interfaces (Chainlit). While primarily educational, the code exhibits production-quality patterns: isolated attention modules, configurable model architecture, well-structured training loops, and robust weight loading with shape validation. The repository is actively maintained with recent commits, cross-platform support (Linux, macOS, Windows), and a strong emphasis on reproducibility (fixed seeds, deterministic settings, environment definitions via pixi/uv/conda). Duplication exists across bonus notebooks and a few hardcoded paths, but the core package and test suite are well-coordinated.
This repository is a comprehensive, educational library of data structures and algorithms implemented in Python 3. It is organized into subpackages by algorithmic category (sorting, searching, graph, dynamic programming, backtracking, bit manipulation, string, tree, math, matrix, compression, streaming, etc.), each containing self-contained modules with clear function signatures, docstrings, complexity analysis, and often multiple implementation variants. The library is installable via pip and intended for learning, reference, and reuse in competitive programming or software development. It is not an application or data pipeline; it has no web server, CLI entry point, or external runtime dependencies beyond the Python standard library. The architecture is a flat library with a shared `algorithms/common` module providing reusable data types (`TreeNode`, `ListNode`, `Graph`) and each subpackage re-exporting its public API through `__init__.py` files. The codebase demonstrates a mix of modern and legacy Python styles, with newer modules using type hints, dataclasses, and doctests, while older modules rely on bare comments and local node definitions. Despite some inconsistencies and minor bugs, the repository is a well-structured, actively maintained collection that serves as a valuable reference for algorithm implementations.
This is the official PyTorch tutorials repository, a Sphinx-Gallery documentation site that publishes to pytorch.org/tutorials. It contains hundreds of executable tutorial scripts covering beginner to advanced PyTorch topics (neural networks, distributed training, torch.compile, performance profiling, custom operators, etc.). The repository is not a standalone application but a documentation generator with sophisticated CI/CD pipelines for building, sharding, and testing tutorials across multiple GPU configurations. It includes extensive build tooling (Docker, Jenkins, GitHub Actions), linters, spell checking, link validation, and redirect management. The code within tutorial files is pedagogical and not production-ready; however, several utility scripts and patterns are reusable for documentation projects and PyTorch extension development.
Opencast is a mature, open-source lecture capture and video management platform designed for educational institutions. It provides a complete pipeline for recording, processing, managing, and distributing academic video content. The system is built as a modular Java application using OSGi (Karaf) for service composition, with a REST API and a GraphQL layer for modern client interactions. Core capabilities include scheduled capture from lecture hall devices, automated workflow-driven processing (transcoding, transcription, captioning, silence detection, video editing), versioned asset storage (with AWS S3 support), multi-channel distribution (YouTube, OAI-PMH, streaming servers), and a rich admin UI for metadata management, access control, and analytics. The architecture follows a microservices-like pattern with separate API, implementation, and remote proxy modules, enabling distributed deployment across worker, admin, and presentation nodes. External dependencies include Elasticsearch/OpenSearch for search indexing, a relational database (MySQL/MariaDB/PostgreSQL), FFmpeg for media inspection and processing, and various cloud services for transcription and publication. The codebase demonstrates strong engineering practices with consistent module structure, extensive test coverage, and a well-documented upgrade path spanning over a decade of development.
JPlag is a mature source-code plagiarism detection engine delivered as a Java library, a picocli-based CLI, and an embedded Vue.js report viewer. In production it parses submissions into language-specific token streams (via ANTLR, JavaCC, or custom parsers), compares token sequences pairwise using greedy string tiling with rolling hashes, merges fragmented matches, applies frequency-based weighting, optionally clusters submissions, and writes a .jplag ZIP report containing JSON models consumed by the viewer. The CLI can also start a local HTTP server to browse results. Architecturally it is a multi-module Maven project: core contains the comparison pipeline and reporting; language-api and language-antlr-utils define a plugin SPI for adding languages; languages/* provides 20+ modules; cli assembles the executable; report-viewer is an npm workspace with model/parser/ui-components packages. Key entry points are de.jplag.cli.CLI and de.jplag.JPlag.run(). External dependencies include ANTLR, picocli, Jackson, JGraphT, Apache Commons Math, and the Vue/TypeScript ecosystem. Although primarily an application, it embeds research-grade components such as spectral and agglomerative clustering with Bayesian optimization, token-sequence normalization, and match-frequency weighting, and it is backed by academic publications. It is not a data pipeline; the inputs are source-code submissions and the output is a similarity report. The repository is actively maintained with extensive CI, end-to-end gold-standard tests, and dependabot, though some language grammars lag language evolution and a few deprecated APIs remain.
This repository is a comprehensive, open-source textbook for data structures and algorithms, known as 'Hello Algo'. It provides implementations of over 200 classic algorithms across 12 programming languages (Python, Java, C++, Go, Rust, etc.) and multiple human languages (Chinese, English, Japanese, Russian). The code is organized into chapters covering complexity analysis, arrays, linked lists, stacks, queues, hashing, trees, heaps, graphs, sorting, searching, divide-and-conquer, backtracking, dynamic programming, and greedy algorithms. Each algorithm is presented as a self-contained, runnable example with driver code and inline comments explaining the logic. The repository is not a production application but a pedagogical reference, making it valuable for students, educators, and self-learners. While the code is well-structured and consistent across languages, its high duplication across languages and translations means it is not designed for production reuse. However, the utility modules for tree/linked list construction and printing are cleanly isolated and can be extracted for other projects.
This repository is a comprehensive educational curriculum for Machine Learning, structured as a collection of Jupyter notebooks, data files, and instructional documentation. While it contains small application examples (a Vue.js quiz app and a Flask web app demo), the dominant character is data research and education, focusing on teaching ML concepts through practical data science workflows. The content covers Regression, Classification, Clustering, NLP, Time Series, and Reinforcement Learning, utilizing Scikit-learn as the primary modeling library. The codebase is organized into modular lesson directories, each containing notebooks, assignments, and solutions. It demonstrates a strong commitment to accessibility with extensive multi-language translations and a devcontainer setup for consistent environments. However, reproducibility is impacted by a reliance on external datasets (Kaggle, Dropbox) which are prone to link rot, and scattered dependency management across different lesson folders rather than a unified root configuration. Technically, the repository shows signs of medium drift, particularly in the quiz application which utilizes Vue 2 patterns instead of the modern Vue 3 Composition API. The core ML content remains relevant, but the educational infrastructure (translation services, external links) requires ongoing maintenance to ensure accuracy and availability. Despite this, it stands as a high-quality, reusable resource for learning ML pipelines and data engineering patterns.
This repository is a comprehensive educational curriculum for Data Science, structured as a 10-week, 20-lesson course designed for beginners. It functions primarily as a data_research asset, containing Jupyter notebooks, R scripts, Python examples, and curated datasets (CSV, TSV) used for Exploratory Data Analysis (EDA) and visualization. The content covers the full data lifecycle, from data definition and ethics to cloud deployment on Azure, utilizing tools like Pandas, Matplotlib, Seaborn, and ggplot2. While the core is educational data content, it includes a hybrid application component: a Vue.js-based quiz application (`quiz-app`) used for assessments. The repository is heavily localized, with content translated into dozens of languages using an AI translation service, which introduces a specific maintenance pattern involving disclaimers about translation accuracy. The data lineage is well-documented, sourcing datasets from Kaggle, USDA, and Wikipedia, with clear licensing information provided. The codebase is optimized for learning rather than production engineering. Notebooks serve as the primary execution environment, demonstrating data cleaning, visualization, and basic statistical analysis. The architecture is flat and modular, organized by lesson topics (Introduction, Working With Data, Visualization, Lifecycle, Cloud). It is highly valuable for educators and learners seeking reproducible data science examples, though the heavy reliance on AI translation and mixed Vue versions (2 vs 3) presents technical drift risks.
memory_graph is a Python library for visualizing the structure of Python data as graphs, primarily used for debugging and teaching concepts like references, mutability, and shallow/deep copy. It takes any Python data (e.g., locals(), call stack frames) and generates a Graphviz-based graph (PDF, PNG, SVG) showing the hierarchical relationships and shared references. The library supports multiple node types (leaf, linear, key-value, table), configurable slicing to limit graph size, call stack visualization with IDE-specific stack frame filtering, and extensions for numpy, pandas, and PyTorch types. It is designed to be used interactively in debuggers (VS Code, PyCharm, etc.) or programmatically via functions like `show()`, `render()`, and `block()`. The codebase is well-structured with clean separation of concerns (node types, slicing logic, configuration, HTML table generation) and includes unit tests for core components.
This repository is a community-curated directory of free programming books, tutorials, and learning resources, organized as Markdown files by language and topic. It is not a software application; the repository's content is its data. The primary artifacts are hundreds of Markdown files (e.g., books/free-programming-books.md, books/free-programming-books-<lang>.md) that form a hierarchical index of external links. Supporting infrastructure includes GitHub Actions workflows for link validation (check-urls.yml), RTL/LTR text linting (scripts/rtl_ltr_linter.py), stale PR management, and PR conflict detection. The repo is one of GitHub's most-starred projects and functions as a massive, community-governed reference dataset rather than executable code. The only analytical tool is the RTL/LTR linter, which scans Markdown for bidirectional text issues and is configurable via YAML. The repository demonstrates strong community governance patterns: issue templates, PR templates, automated linting, and stale-issue management. However, it faces inherent challenges of link rot and version staleness across thousands of external URLs. The hybrid nature is notable: it is a data repository (Markdown as data) with software-engineering practices (CI, linting, automation) applied to maintain data quality.
This is the main application for The Odin Project, a free and open-source web development curriculum. It is a Rails 8.1 monolith that provides a learning management system (LMS) with user authentication, lesson tracking, project submissions, flagging/moderation, and an admin panel. The application imports lesson content from a separate GitHub repository, converts Markdown to structured HTML using custom Kramdown converters, and tracks user progress through materialized SQL views. It features a modern Hotwire frontend (Stimulus + Turbo), Tailwind CSS, and extensive use of ViewComponents. The codebase is well-tested with RSpec, including system and request specs. While primarily an application, it includes analytical reporting via materialized views and daily summary jobs, giving it a hybrid nature leaning heavily toward application.
This repository is an interactive, cyberpunk-styled periodic table of elements web application. It displays all 118 elements with detailed data, supports multiple visualization modes (standard, heatmap for properties like radius, electronegativity, ionization energy, melting point, boiling point, density), category filtering, real-time search, and a 3D atomic model viewer. The application is fully bilingual (Chinese/English) and responsive across devices. The architecture is a single-page application built with TypeScript and Vite. The codebase is modular, with clear separation into modules for table rendering, heatmap, 3D atom, modal, media loading, search, and legend. State is managed centrally, and internationalization is handled via typed translation dictionaries. The project includes unit tests using Vitest and a CI/CD pipeline for GitHub Pages deployment. Key technical highlights include a pure-function electron configuration algorithm (Aufbau principle with exceptions), CSS 3D transforms for the atom model, and a lightweight i18n system. The code is type-safe with strict TypeScript and follows modern frontend best practices.