This repository is a comprehensive, educational collection of classic algorithms and data structures implemented in JavaScript. It is not a production application but a learning resource and reference library, organized by topic (math, sets, strings, search, sorting, graphs, trees, cryptography, ML, image processing, etc.) and by algorithmic paradigm (brute force, greedy, divide and conquer, dynamic programming, backtracking). Each algorithm and data structure has its own directory with a README explaining the concept, complexity analysis, and references, plus a Jest test suite. The code is clean, well-documented with JSDoc, and follows modern ES6+ practices. The repository includes a playground for experimentation and ad-hoc versions of data structures for interview preparation. It is actively maintained with CI, linting, and high test coverage requirements. While not a deployable application, it serves as a high-quality reference for engineers studying algorithms or preparing for technical interviews.
MiniMind is an educational open-source toolkit for training small language models entirely from scratch using native PyTorch. It provides a complete pipeline including custom BPE tokenizer training, pretraining, supervised fine-tuning (SFT), LoRA, RLHF (DPO), RLAIF (PPO/GRPO/CISPO), agentic reinforcement learning, and knowledge distillation. The system is designed to be accessible (low compute cost, ~3 RMB and 2 hours on a single GPU) and includes inference interfaces such as a CLI, Streamlit web UI, and an OpenAI-compatible API server. While primarily a software application for training and deploying LLMs, it also contains dataset preparation, evaluation benchmarks, and research experiments, giving it a hybrid character that leans toward application due to its focus on providing reusable training scripts and deployment tools.
This repository contains the source code for Comprehensive Rust, a multi-day Rust course developed by the Android team at Google. It is structured as an mdBook with slides, speaker notes, interactive code examples, and exercises. The course covers Rust fundamentals, Android and Chromium integration, bare-metal development, concurrency, async, unsafe Rust, and idiomatic patterns. The codebase includes custom mdBook preprocessors (mdbook-course for structured course scheduling, mdbook-exerciser for extracting exercise starter files), a developer automation tool (xtask), and a comprehensive CI/CD pipeline that builds the book in multiple languages, runs Rust tests via Bazel and Cargo, and performs browser-based WebDriverIO tests. While the primary output is educational content, the tooling infrastructure is well-engineered and demonstrates reusable patterns for structured documentation and exercise management. The repository is actively maintained with frequent commits, issue triage, and translation support for over 17 languages.
This repository is the official companion code for the book "Build a Reasoning Model (From Scratch)" by Sebastian Raschka (Manning, 2025). It is primarily a data_research codebase focused on building, evaluating, and training reasoning LLMs from scratch using the Qwen3 0.6B model as a base. The code covers inference-time scaling (temperature/top-p sampling, self-consistency), reinforcement learning from verifiable rewards (GRPO/RLVR), self-refinement, and knowledge distillation from larger teachers (DeepSeek-R1, Qwen3 235B). It includes a full custom Qwen3 implementation with KV cache, RoPE, and grouped-query attention, plus training scripts, notebooks, benchmark evaluations (MATH-500, MMLU), and Hugging Face export adapters. While educational in nature, it demonstrates production-quality engineering for research experiments. The repository is hybrid: it provides a reusable Python package for text generation and training, but its dominant character is data_research due to its notebook-driven, experimental, and benchmark-focused workflow.
This repository is a comprehensive catalog of software design pattern implementations in Java, maintained by Ilkka Seppälä (iluwatar). It contains over 300 self-contained modules, each demonstrating a classic GoF pattern, architectural pattern, concurrency pattern, or microservices pattern. The code is educational and demonstrative rather than production-ready, with each module providing a runnable App.java entry point, clear class hierarchies, and accompanying unit tests. The project serves as a reference for developers learning design patterns, and the implementations are intentionally simplified to focus on the pattern's mechanics. The architecture is modular: each pattern lives in its own Maven module with a consistent structure (main source, test source, documentation images, and localized READMEs). Some modules integrate with Spring Boot, JPA/Hibernate, Kafka, or MongoDB for realistic context, but the vast majority use in-memory data structures. The codebase spans Java 8 to modern features, with extensive use of Lombok, SLF4J, and JUnit 5. While not a single deployable application, the repository effectively demonstrates how patterns solve common design problems. Notable for both its breadth and craftsmanship, the repository includes patterns from creational (Builder, Factory), structural (Adapter, Proxy), behavioral (Observer, Strategy), and architectural (Hexagonal, Clean Architecture) categories. Many modules implement reusable abstractions (e.g., Converter, Specification, Filterer, EventDispatcher) that can be extracted and used in new projects. The project's high star count and active contributor base reflect its status as a primary learning resource for Java design patterns.
This repository is a comprehensive educational and research resource for low-level systems programming, focusing on Linux kernel modules, baremetal programming, CPU architectures (x86_64, ARM, AArch64), and emulation with QEMU and gem5. It contains hundreds of self-contained examples—from trivial 'hello world' kernel modules to advanced topics like IRQ handling, RCU stalls, inline assembly patterns, CPU pipeline hazards, and floating-point arithmetic. The repository is not a production application but rather a knowledge base with automated build and test infrastructure that systematically verifies correctness across multiple architectures and emulators. It also serves as a reference for gem5 simulation, including checkpoint/restore, performance counters, and benchmarking (e.g., Dhrystone, cache performance). While primarily a research/teaching tool, it includes a reusable Python automation framework (CLI generators, parallel test runners, path-based property configuration) that could be extracted for other projects. The repository is hybrid in nature: its core content is data/research (experimental, analytical), but it incorporates application-quality infrastructure.
This repository is the official Python implementation of the algorithms from the textbook *Artificial Intelligence: A Modern Approach* (AIMA) by Russell and Norvig. It is primarily an educational library, providing clean, well-documented reference implementations of classic AI algorithms. The code is organized as a monolithic Python package (`aima/`) with modules corresponding to major AI subfields (search, logic, probability, learning, NLP, planning, agents, etc.), complemented by an extensive set of Jupyter notebooks that serve as interactive tutorials and a JupyterLite deployment for browser-based execution. The architecture emphasizes clarity and adherence to textbook pseudocode over production performance. The library demonstrates high craftsmanship in its core abstractions. The `Problem`/`Node` search framework, the `Expr` symbolic logic engine, the `BayesNet` probabilistic inference system, and the `CSP` constraint satisfaction framework are all well-isolated, reusable components that could be extracted for other projects. The code is extensively tested with pytest and actively maintained, with a very low open issue count relative to its popularity. While the core library is robust and written in pure Python with minimal dependencies, some modules (particularly `deep_learning.py` and `perception.py`) rely on heavy external libraries like TensorFlow/Keras and OpenCV, which have experienced significant API drift over time. The educational focus means the code prioritizes readability and algorithmic correctness over scalability or performance optimization. Overall, it is an invaluable resource for learning AI and a solid foundation for building educational tools and demonstrations.
The Linux Kernel Module Programming Guide (LKMPG) is a comprehensive, community-maintained guide to writing Linux kernel modules. It consists of a LaTeX book and a large collection of example kernel modules that demonstrate a wide range of kernel APIs and programming patterns, including character devices, the /proc filesystem, sysfs, debugfs, system call interception, synchronization primitives (mutex, spinlock, rwlock, RCU), interrupt handling, timers, workqueues, block devices, network drivers, DMA, device tree, GPIO, and more. The repository also includes a QEMU-based development environment (devtools) that automates building a minimal kernel and initramfs, allowing developers to compile and test modules inside a virtual machine without affecting their host system. The code is well-structured, follows kernel coding conventions, and includes proper error handling and cleanup. Many examples include version guards for compatibility across different kernel versions (5.10 through 6.17+). The devtools scripts are robust, with caching, idempotency, and prebuilt binary support to speed up setup. The CI pipeline builds the book, compiles all examples, runs static analysis (cppcheck, sparse, gcc, smatch), and tests module loading/unloading in both bare-metal and QEMU environments. While primarily educational, the example modules are self-contained and can serve as templates for real kernel module development. The devtools provide a reproducible environment for kernel module testing, which is valuable for developers working on out-of-tree modules. The repository is actively maintained and targets recent Linux 5.x and 6.x kernels.
Rust Quiz is a monolith application that hosts a collection of medium-to-hard Rust quiz questions. The core function is to parse Markdown question files and corresponding Rust source files, compile and execute the Rust code to verify correct answers, and generate a JavaScript bundle for a static website. It uses a parallel worker pool (rayon) for efficient validation and includes a local HTTP server based on hyper for development. The codebase is well-structured with clean error handling (thiserror) and modern Rust practices. While the primary value is the question content, the build tooling is a robust example of a Rust code snippet tester with output validation and warning checking.
This repository is an educational book/course titled 'Learn Go with Tests' by Chris James. It teaches the Go programming language through test-driven development (TDD), building small but complete example applications incrementally. The code is organized by chapter with progressive versions (v1, v2, ...) that demonstrate the TDD red-green-refactor cycle. The primary example application is a poker/league scoring system with an HTTP server, JSON file persistence, a CLI interface, and WebSocket support for real-time games. Other examples include an SVG analog clock generator, a blog post renderer using HTML templates, a dictionary with CRUD operations, and various standalone concept demonstrations (concurrency, context, reflection, generics). The repository is not a single production application but a collection of well-tested, pedagogical code that illustrates idiomatic Go patterns, interface-based design, dependency injection, and testing strategies (unit tests, acceptance tests, property-based tests, and test doubles).
C++ Insights is a source-to-source transformation tool built on LLVM/Clang that reveals compiler-generated code by making implicit C++ mechanisms explicit. It processes C++ source through Clang's AST, applies transformations to show template expansions, lambda desugaring, coroutine state machines, lifetime tracking, and other low-level details, outputting valid C++ that illustrates what the compiler does internally. The architecture centers on AST traversal via custom visitors and code generators, with modular components for different transformation modes (standard, Cfront-style, coroutine-specific). Key entry points include Insights.cpp (main driver) and specialized generators like CoroutinesCodeGenerator.cpp. The tool serves an educational purpose, helping developers understand C++ language semantics through visualizing compiler transformations.
This repository is a comprehensive educational resource for data engineering, structured as a handbook and bootcamp. It contains curated learning paths (beginner, intermediate, Databricks AI bootcamp) with lecture materials, homework, and sample datasets. The codebase includes teaching examples of core data engineering patterns: dimensional data modeling (cumulative tables, SCD type 2), fact data modeling (array metrics, datelist int), Apache Spark jobs with unit tests, Apache Flink streaming jobs, and analytical SQL patterns (retention, funnel, grouping sets, growth accounting). It also includes a small Flask server for A/B experimentation and Docker Compose setups for local development. While primarily educational, the SQL scripts and job templates are production-quality and reusable across projects. The repository is actively maintained with pinned dependencies and clear documentation, making it highly reproducible for learners.
Typed Japanese is a TypeScript type-level library that models Japanese grammar as composable generic types, enabling the construction of grammatically valid Japanese sentences entirely within the type system. The core library defines interfaces for verbs (godan, ichidan, irregular), adjectives (i-adjectives, na-adjectives), copulas, particles, and sentence patterns, using template literal types and conditional types to encode conjugation rules. This allows developers to write Japanese sentences as type aliases that resolve to the exact Japanese string, with the TypeScript compiler acting as a grammar validator. The repository also includes an interactive playground web application (React + Vite + Monaco Editor) where users can explore the type system, write and analyze sentences, and follow a bilingual (English/Chinese) tutorial course spanning 47 chapters from elementary to advanced levels. A macOS app (TypedTranslate) provides a native interface for grammar annotation and chat, using a Bun bridge to integrate with the type system and LLMs (Codex/Claude). The project is hybrid in nature: while primarily an application/library, it includes a substantial data/research component in the form of curated evaluation datasets, an LLM annotation pipeline, and a rigorous iterative eval loop that measures conformance, reliability, and capability across grammar categories. The eval system produces quantifiable scoreboards and drives systematic improvements to the library's type definitions, prompt templates, and tutorial content.
This repository is a full-stack Next.js application that serves as the world's largest open-source prompt library for AI. It provides a platform for users to create, share, discover, and manage prompts for various AI models (ChatGPT, Claude, Gemini, etc.). The core functionality includes CRUD operations for prompts with types (text, image, video, audio, skill, taste), voting, commenting, versioning, change requests, collections, and moderation tools. It features AI-powered capabilities such as semantic search via OpenAI embeddings, prompt improvement, translation, quality checking, and media generation through plugin-based providers (Fal.ai, Wiro.ai). The application supports multi-tenancy for self-hosting with configurable branding, authentication plugins (OAuth, OIDC, GitHub, Apple, Google), and storage backends (S3, DO Spaces). Beyond the web app, it includes a CLI tool (packages/prompts.chat) for browsing and running prompts locally, a Raycast extension for quick access, and an MCP server for integration with AI coding assistants. Additionally, it bundles an interactive educational book on prompt engineering (28+ chapters) and a gamified kids learning section, both fully localized into 17 languages. The codebase is well-structured with a plugin registry pattern, configuration-driven design, and extensive use of modern Next.js patterns (App Router, server components, streaming).
This is a comprehensive educational course repository ('Generative AI for Beginners') containing 21 structured lessons covering the full spectrum of generative AI application development. While classified as an application repository due to its extensive runnable code examples across Python, JavaScript, TypeScript, and .NET, its primary purpose is pedagogical. The repository teaches practical patterns for building GenAI applications including: prompt engineering, chat applications, RAG/vector search, image generation, function calling, AI agents, fine-tuning, LLMOps, and responsible AI practices. Each lesson provides assignments and solutions for multiple LLM providers (Azure OpenAI, OpenAI, GitHub Models). The codebase demonstrates modern GenAI application patterns with a strong emphasis on multi-language implementation parity and accessibility through 40+ language translations. The shared/python utilities provide reusable helpers for API interactions, environment management, and input validation that could be extracted for production use.
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 the companion to Allen Downey's Think DSP book. It is primarily an educational Python library plus a collection of Jupyter notebooks, not a production service or a research data pipeline. The core deliverable is the `thinkdsp` package, a self-contained module that provides object-oriented primitives for representing periodic signals (`Signal`, `Sinusoid`, `Chirp`, `Noise`), sampling them into `Wave` objects, and transforming between time and frequency domains via FFT and DCT. The library also supports spectral arithmetic, filtering, convolution, autocorrelation, spectrogram generation, WAV file I/O, and basic audio synthesis. The notebooks in `nb/`, `split/`, and `examples/` walk through each chapter of the book, with solution notebooks and standalone solution scripts in `soln/`.
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 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.