Projects sharing features with Altair

Hoppscotch is an open-source API development ecosystem designed for building, testing, and debugging REST, GraphQL, and real-time APIs. It provides a unified platform that functions across web browsers, desktop applications, and command-line interfaces, allowing developers to manage the entire API lifecycle from a single environment. The platform distinguishes itself through a highly interactive, command-driven interface that utilizes a global spotlight palette and keyboard shortcuts to streamline complex workflows. It supports advanced request manipulation and validation by executing JavaScr

GraphiQL is an interactive browser-based integrated development environment for writing, testing, and documenting GraphQL queries and mutations. It functions as a code editor, an API exploration tool, and a schema explorer, providing a visual interface for browsing GraphQL types and fields. The project provides a language server that delivers schema-driven autocompletion, linting, and validation via the Language Server Protocol. It allows for the embedding of high-performance editors into external projects and supports the injection of custom tools and components through a sidebar plugin API.

GraphQL Playground is an interactive development environment and API client used for writing, testing, and debugging GraphQL queries, mutations, and subscriptions. It functions as a visual tool for executing requests against a GraphQL server and inspecting the resulting JSON responses. The project includes a documentation browser for exploring schemas and an editor with autocompletion and error highlighting. It provides specialized capabilities for analyzing API performance through tracing visualization and supports real-time data updates via subscription streaming. The environment allows fo

HotChocolate is a GraphQL server implementation for .NET that handles queries, mutations, and subscriptions over HTTP. It provides code-first schema generation directly from C# classes and attributes, keeping the schema and business logic in sync without manual type definitions. The project also includes a GraphQL gateway that composes multiple GraphQL and REST endpoints into a single unified schema, along with a GraphQL IDE for exploring, testing, and debugging GraphQL APIs interactively. The project distinguishes itself through its comprehensive tooling ecosystem, which includes a GraphQL c

This is a Visual Studio Code extension that lets developers compose, send, and inspect HTTP requests directly from within the editor. It uses .http and .rest files as executable request definitions, parsing each block of text into a complete HTTP request that is dispatched via Node.js built-in HTTP modules without requiring a separate server process. The extension renders full HTTP responses with syntax-highlighted body, status line, and headers in a dedicated editor tab or side panel. The extension supports multiple authentication schemes including Basic, Digest, SSL certificates, Azure

express-graphql is a GraphQL API server implementation and HTTP middleware that connects a GraphQL schema to an HTTP server. It provides a request parser to extract queries and variables from various content types and a context provider to inject HTTP request data and session state into resolver functions. The library includes a browser-based interactive IDE that detects GET requests to serve an HTML interface for testing queries and inspecting responses. It also supports a custom execution pipeline, allowing for the override of default parsing, validation, execution, and error formatting fun

This project is a strongly-typed GraphQL client library and code generator designed for Android, JVM, and Kotlin Multiplatform. It provides a toolset for executing queries and mutations, generating immutable classes and parsers from GraphQL schemas to ensure compile-time type safety. The library features a normalized client-side caching system that flattens server responses into a lookup table to maintain a single source of truth. It includes a specialized subscription client for handling real-time server-side updates via WebSockets or Server-Sent Events, and a mocking framework for simulatin

GraphQL Editor is a collaborative workspace platform for designing, editing, and managing GraphQL schemas. It provides an interactive graph-based visual editor that lets teams create and explore schemas without writing code, alongside a full-featured Monaco text IDE with real-time syntax validation. The platform supports AI-powered schema generation from natural language prompts, federated schema composition that visualizes type merging across subgraphs, and AST-level schema comparison that highlights structural differences between versions. The platform distinguishes itself through its bidir

GraphQL Voyager is a schema visualizer and data model explorer that provides an interactive graph representation of a GraphQL API. It serves as a documentation tool for inspecting types and fields by transforming schema introspection data into a visual interface. The tool maps the relationships between different types and fields, allowing for the analysis of complex data models and their connections. Users can filter the visual representation to remove deprecated fields or wrapper classes and use a dedicated information panel to examine technical specifications for specific data types.

Yaak is a cross-platform desktop client and command-line utility designed for developing, testing, and debugging API endpoints. It supports multi-protocol request execution for REST, GraphQL, and gRPC services, providing a unified environment for managing network interactions, authentication credentials, and automated testing workflows. The tool distinguishes itself through a local-first architecture that stores all workspace configurations and request definitions directly on the filesystem. This design enables native integration with version control systems like Git, allowing teams to track

Spring GraphQL is a Java framework designed for building GraphQL services by mapping schema definitions directly to backend controller logic. It provides a reactive execution engine that processes queries and subscriptions asynchronously, supporting multiple network transports to facilitate communication between clients and data sources. The framework distinguishes itself through annotation-driven request routing, which decouples schema definitions from business logic to reduce implementation boilerplate. It includes native support for federated service composition, allowing developers to agg

req is a chainable HTTP client library for Go designed to simplify request configuration and automatic response decoding into structures. It provides a fluent-interface request builder that allows developers to incrementally define request properties and encapsulate HTTP logic into reusable API SDKs. The project distinguishes itself with a TLS fingerprint emulator that mimics browser network signatures to bypass bot detection and crawler filters. It also includes a concurrent file downloader that increases transfer speeds by fetching large remote files in parallel segments. The library cover

Koa is a lightweight web framework for Node.js designed for building HTTP applications and servers. It functions as an asynchronous middleware engine that processes network requests through a sequence of functions sharing a common context. The framework distinguishes itself by using an onion-model middleware stack and promise-based flow control. This architecture allows requests to flow downstream and responses to flow back upstream through the same chain, enabling non-blocking request cycles and a modular approach to handling network traffic. The system provides high-level capabilities for

This project is a comprehensive educational resource and fullstack tutorial for GraphQL development. It provides instructional content and guides focused on designing schemas, implementing servers, and managing the end-to-end workflow of building production-ready applications. The material covers the conceptual differences between graph-based data structures and traditional API architectures. It includes a dedicated security course and guides for client integration, teaching users how to fetch data, manage application state, and apply protection measures to secure API endpoints. The scope of

GraphQL Platform is a comprehensive GraphQL ecosystem for .NET that provides a spec-compliant server framework for building APIs and gateways, along with a typed C# client for consuming GraphQL services. At its core, it translates C# classes and methods into a GraphQL schema using code-first or fluent descriptor approaches, enabling developers to define their API structure directly from their existing .NET code. The platform distinguishes itself through several integrated capabilities that address common GraphQL production concerns. It includes a DataLoader batching and caching engine that gr

apollo-ios is a GraphQL client library for iOS and Apple platforms that enables type-safe network communication. It transforms GraphQL operations into generated Swift models, ensuring that network responses are validated at compile time to eliminate manual mapping. The library features a normalized cache manager that stores entities in a flat structure to maintain data consistency across different application views. It also optimizes network performance using hash-based persisted queries to reduce payload sizes and supports real-time data streaming via WebSockets or HTTP subscriptions. The p

Bruno is a local-first API client designed for building, testing, and managing network requests across a wide range of protocols. By storing all collections and configurations as plain-text files directly on the local filesystem, it enables native version control and offline access, ensuring that project data remains under user control without requiring cloud synchronization. The platform distinguishes itself through a declarative approach to API management, utilizing a domain-specific language to define request parameters and metadata. This architecture supports a robust testing environment

DesktopEditors is an office suite application designed for creating and editing text documents, spreadsheets, and presentations across different operating systems. It serves as an OOXML compatible editor, ensuring that files are read and written according to Office Open XML standards for cross-platform document exchange. The suite functions as a collaborative document platform featuring real-time co-authoring, version tracking, and integrated communication tools. It also acts as an AI-powered document assistant and PDF editor, providing capabilities for content generation, automated spreadshe

graphql-request is a lightweight, type-safe GraphQL client library for JavaScript that runs across browsers, Node.js, and other JavaScript environments. It provides a minimal HTTP client for sending queries and mutations, with a promise-based execution model that uses the native fetch API for cross-runtime compatibility without additional dependencies. The client supports reusable selection set composition at runtime, allowing fragments to be shared across multiple requests to reduce duplication. It includes a plugin-based extension system for adding custom middleware, tracing, or file upload

Bagisto Next.js Commerce is a headless, server-side rendered e-commerce storefront built on Next.js that connects to any backend commerce API exclusively through GraphQL. It delivers SEO-optimized product pages with fast initial loads by combining server-side rendering with incremental static regeneration, and automatically optimizes images for different devices and network conditions. The storefront decouples the user interface from backend commerce logic, enabling flexible integration with any API protocol without modifying the frontend code. It supports the full shopping lifecycle includin

Apollo Kotlin is a strongly-typed GraphQL client and code generation library designed for Kotlin and JVM applications. It functions as a comprehensive development tool that transforms GraphQL schema definitions and query documents into type-safe models during the build process, ensuring that data access errors are identified at compile time rather than at runtime. The project distinguishes itself through its multiplatform runtime abstraction, which allows developers to share data fetching and caching logic across Android, iOS, and desktop environments. It provides a normalized local caching s

node-http-proxy is a Node.js HTTP proxy library used for forwarding requests to target servers. It functions as reverse proxy middleware capable of mapping incoming routes to target destinations and transforming request and response data streams. The library includes a WebSocket proxy gateway that upgrades standard HTTP connections into bidirectional streams between clients and backend servers. It also provides a response transformer for modifying bodies, location headers, and cookie domains. The project covers traffic routing management via rule-based translation tables and secure connectio

GraphQL Redis Subscriptions is a real-time event streaming library and publish-subscribe engine that delivers GraphQL subscription events across distributed server instances using Redis. It routes real-time messages through an external data store so multiple server instances can share and process identical client events. The library coordinates message delivery through distributed pub-sub brokerage and handles binary-safe data streams directly from the messaging layer by bypassing default string conversions. It supports custom serialization pipelines that transform outgoing and incoming paylo

Wretch is a chainable HTTP client library and Fetch API wrapper designed to simplify network request configuration, response parsing, and error handling. It functions as a network request manager and middleware framework for managing the end-to-end lifecycle of HTTP calls. The project is distinguished by a fluent interface for request configuration and a modular extension system. It utilizes a programmable response resolver to automate parsing and a plugin-based architecture to add new capabilities to request and response objects. The library covers a broad range of operational capabilities,

Kore is an event-driven web and WebSocket server framework designed for building high-performance web services and APIs in C or Python. It functions as a secure, concurrent application framework that utilizes non-blocking I/O and isolated worker processes to handle high-concurrency traffic. The project is distinguished by a security-first architecture that features OS-level process sandboxing, privilege separation, and the isolation of private encryption keys into dedicated processes. It enables zero-downtime deployments through dynamic module hot-reloading and provides automated TLS certific

This project is a PHP environment compatibility library and polyfill designed to provide a consistent interface for retrieving all incoming HTTP request headers. It functions as a request header parser that extracts and normalizes raw server variables into a predictable associative array. The library ensures cross-platform behavior by detecting missing native functions at runtime and injecting fallback implementations. This allows for standardized request header retrieval and server variable normalization across diverse server architectures and configurations.