Explore by area

This cluster represents the ecosystem of tools, agents, and integrations built around Claude AI and the Model Context Protocol (MCP) standard. It includes frameworks for building AI agents that use Claude, MCP server implementations, code generation tools, and productivity utilities that extend Claude's capabilities. Someone exploring this area would find agent scaffolding systems, context protocol servers, prompt engineering libraries, and practical integrations designed to automate coding and knowledge work tasks.

A cluster of foundational OCaml libraries and tools for systems programming, data handling, and development infrastructure. The repos center on low-level abstractions (cstruct for memory buffers, astring for strings, logs for logging), serialization/data formats (jsonm for JSON), reactive programming (react), and build tooling (topkg). This represents the core utility layer of the OCaml ecosystem that many production systems depend on.

A cluster focused on building and managing distributed database systems, data stores, and related infrastructure. The repos span multiple implementation languages (Erlang, Go, Rust) and include both foundational systems (etcd, redis, cockroach) and tools for database interaction and management (dbeaver, Chat2DB). This represents a mature area with repos addressing consistency, replication, querying, and operational tooling for modern data systems.

A collection of Haskell projects focused on developer tools, code generation, and practical libraries for common tasks. Central repos include clap4shell (command-line argument parsing), deriving-aeson (JSON serialization code generation), mason (project scaffolding), and xml-lens (XML data manipulation). This cluster represents the pragmatic Haskell ecosystem where developers build reusable abstractions and tooling to reduce boilerplate and improve developer experience.

This cluster represents the ecosystem around StandardJS, a popular JavaScript linting and code style standard that enforces a consistent, opinionated coding style without configuration. The repositories include the StandardJS linter configuration itself, ESLint plugins for React and JSX support, documentation sites, and curated lists of related tools and resources. Someone exploring this area would find comprehensive tooling for enforcing JavaScript code quality and consistency across Node.js projects and web development.

This cluster centers on the Cosmos SDK ecosystem and blockchain infrastructure, combined with smart contract language design and implementation. It includes core Cosmos projects (cosmos-sdk, cometbft, evmos, cronos), alongside compiler and language projects like opshin that enable smart contract development across different blockchain platforms. Someone exploring this cluster would learn about blockchain consensus, interoperability protocols, and how domain-specific languages are designed for decentralized applications.

This cluster represents the core WebAssembly (WASM) standardization and language feature development effort, centered on the official spec repository and active proposals for extending the language. The repositories cover fundamental extensions like garbage collection, exception handling, stack switching, memory64, and JavaScript promise integration—all key features under active standardization. Someone exploring this cluster would find the specification documents, test suites, and proposal implementations that define WebAssembly's evolution and interoperability with JavaScript and modern runtime systems.

This cluster centers on formal verification and proof development using Lean 4, with strong emphasis on cryptographic systems and programming language theory. The repos include core Lean tooling (ProofWidgets4), foundational cryptographic verification (libcrux, HACL*), theorem proving infrastructure (quote4), and related formal methods research. Someone exploring this area would find resources for learning formal verification practices, verified cryptographic implementations, and the Lean ecosystem for mathematical proof development.

This cluster represents projects focused on operating system design, kernel development, and low-level systems programming. It includes both experimental OS implementations (like BlogOS and ReactOS), container/orchestration platforms (Maestro), functional language-based systems work (reflected in Haskell presence), and infrastructure-as-code tooling (Nix ecosystem). Developers interested in OS internals, kernel hacking, systems architecture, or reproducible builds will find relevant projects here.

This cluster combines HTML/DOM parsing libraries with error monitoring and exception tracking tools. The core includes htmlparser2, domhandler, and domutils—foundational JavaScript/TypeScript packages for parsing and manipulating HTML documents—alongside Sentry SDKs for Python and Ruby that provide application error tracking and reporting. Someone exploring this cluster would find both low-level utilities for working with HTML structure and higher-level infrastructure for monitoring application health across multiple languages.

This cluster centers on building Rust-based infrastructure for ROS 2 (Robot Operating System 2), including native Rust client libraries, middleware bridges like Zenoh, and visualization/debugging tools. The core repos provide Rust bindings and alternatives to ROS 2's traditional C++ stack, DDS integration via Zenoh plugins, and utilities like URDF visualization. Someone exploring this area would find production-ready frameworks for writing robotics applications in Rust, cross-language communication layers, and developer tooling for the ROS 2 ecosystem.

A focused cluster of utilities for formatting and manipulating text output in command-line interfaces, centered on ANSI color/style handling, text wrapping, and template strings. Core repos like chalk and chalk-template provide high-level APIs for colored terminal output, while supporting libraries like strip-ansi, ansi-regex, and wrap-ansi handle lower-level text processing and regex operations. This is the practical foundation layer that Node.js CLI tools build on for readable, styled terminal output.

This cluster focuses on typeface design, font development tools, and font file format parsing. It includes font family projects (YoungSerif, Lora-Cyrillic, Work-Sans, inter, Tektur), low-level font parsing libraries (ttf-parser), and supporting infrastructure for working with OpenType and variable fonts. Someone exploring this area would find both finished typeface designs ready for use and the technical tools needed to build, test, and validate fonts programmatically.

This cluster represents the Elm programming language ecosystem, centered on functional web development tools and libraries. The repositories include core Elm infrastructure (compiler, markdown parsing, HTML/JavaScript interop), application frameworks (start-app), testing utilities (expectations), and supporting documentation systems. Someone exploring this cluster would learn about building type-safe single-page applications, Elm's approach to frontend architecture, and the language's developer tooling.

This cluster centers on Jane Street's OCaml libraries for incremental computation, reactive programming, and compile-time code generation via PPX (preprocessor extensions). The core repos include Incremental (for efficient recomputation of derived values), Incr_dom (UI framework built on Incremental), Ecaml (Emacs plugin bindings), and PPX tools like ppx_expect, ppx_compare, and ppx_sexp_conv that automate serialization and testing. Someone exploring this would learn about functional reactive programming patterns, OCaml metaprogramming, and how to build high-performance data-driven systems with automatic dependency tracking.

This cluster centers on static analysis tools and practices for detecting bugs, security issues, and code quality problems without executing code. It's anchored by Semgrep (a pattern-based code scanning tool) and complementary tools like Infer (Facebook's static analyzer) and NullAway (null safety checker), with strong GitHub Actions integration for CI/CD workflows. Someone exploring this cluster would learn about AST-based analysis, rule-writing, and how these tools integrate into modern development pipelines across multiple languages (Java, Go, Python, etc.).

This cluster centers on functional programming languages, type systems, and lambda calculus implementations, with a strong emphasis on Haskell and JavaScript-based explorations of theoretical computer science concepts. The repositories span educational materials, language implementations, and tools for working with dependent types and formal logic. Someone learning this area would find implementations of type checkers, educational articles on type theory, and practical functional programming projects grounded in theoretical foundations.

A cluster of low-level Node.js libraries for HTTP request/response handling, content negotiation, and error management. Core repos like http-errors, content-type, media-typer, and raw-body provide foundational utilities for parsing headers, managing body streams, and standardizing HTTP error responses. These are typically used as building blocks in Express, Koa, and other web frameworks, making this cluster essential infrastructure for Node.js web development.

This cluster centers on Godot engine extensions and tools, particularly for XR/VR development and game creation. The repos include Godot OpenXR integration, text editors built with or for Godot, and related game dev tooling. It represents a focused community around extending Godot's capabilities for immersive experiences and development workflows.

This cluster covers tools and libraries for Protocol Buffers (protobuf), Google's language-neutral serialization format, and gRPC, the high-performance RPC framework built on top of it. You'll find core implementations (protobuf, grpcurl), code generation tools (buf, prototool, protoc-gen-doc), and language-specific bindings (Swift, Go, Haskell). It represents the practical engineering around defining, generating, and consuming protobuf schemas across multiple languages and platforms.

This cluster covers the RISC-V instruction set architecture ecosystem, including compiler toolchains (GNU), ABI/calling conventions documentation, assembly manuals, and optimized mathematical libraries (SLEEF). It represents the foundational infrastructure for building and running software on RISC-V processors, with particular emphasis on performance-critical elementary functions and cross-platform compatibility patterns.

This cluster represents a collection of starter templates and reference applications built around the Azure Developer CLI (AZD) framework. The repos demonstrate how to scaffold and deploy full-stack applications to Azure using infrastructure-as-code tools like Bicep and Terraform, with various backend stacks (Node.js, Python, C#) and data stores (MongoDB, Cosmos DB, SQL). Someone exploring this area would find practical examples of cloud-native application templates, IaC patterns for Azure, and end-to-end deployment workflows.

osm, ocaml-android, opam-android-repository, mountains, theo, ocaml-smithy

vale, neomake, packages, zsh-autoenv, ale, deoplete.nvim

action, templates, images, spec, template-starter

isolator, recaman, benlib, spikemonger, agent-toolkit-for-aws

nomic, orga, orga, merk, fingerprintjs2