Open-source alternatives to Spec

Nanoclaw is an LLM agent orchestrator and multi-platform chat gateway designed to deploy and manage isolated AI agents. It provides a containerized runtime that executes agents within sandboxed Linux containers, ensuring filesystem and state isolation through dedicated workspaces and host bind-mounts. The project distinguishes itself through a unified routing pipeline that connects agents to diverse messaging platforms, including WhatsApp, Discord, Slack, Telegram, Signal, and iMessage. It integrates the Model Context Protocol to extend agent capabilities via managed external data and functio

The Event Gateway is a unified routing layer designed to connect HTTP requests and cloud events to serverless functions across multiple providers and infrastructure environments. It functions as a centralized platform for managing event-driven architectures, enabling developers to register, map, and trigger remote functions in response to incoming web traffic or asynchronous system events. The platform distinguishes itself through a plugin-based middleware pipeline that allows for custom logic execution during the request lifecycle, enabling developers to intercept, validate, or transform eve

Otto is an event-driven communication system designed as an event bus for Android applications. It provides a mechanism to decouple application components by routing events between them without requiring direct dependencies. The system is state-aware, meaning it can provide the most recent known value to new subscribers immediately upon registration. It operates as a synchronous event dispatcher, ensuring all registered listeners respond to an object before execution continues. The library includes capabilities for event subscription management and thread execution enforcement to restrict ca

kotlinx.serialization is an official Kotlin library that provides a multiplatform serialization framework for converting Kotlin objects to and from multiple data formats. It uses a Kotlin compiler plugin to generate serializer and deserializer code at compile time, avoiding runtime reflection and preserving type safety through annotations like @Serializable. The library supports JVM, JS, and Native targets with platform-specific runtime libraries, enabling consistent serialization across all Kotlin environments. The library distinguishes itself through its multi-format encoder-decoder abstr

Perfetto is a platform for system-level performance tracing and analysis on Linux and Android. It combines a high-throughput trace recorder, a SQL-based query engine, and a browser-based visualizer into a single toolchain. The platform covers CPU scheduling and call-stack profiling, native and Java heap memory allocation tracking, GPU and graphics events, and system-wide counters such as CPU frequency and power consumption. The architecture decouples trace recording from offline analysis, using a compact protobuf format for event encoding and columnar storage for efficient SQL queries. The we

Gravity is an embeddable, bytecode-compiled programming language designed to provide programmable logic within host applications. It is a garbage-collected language that utilizes a mark-and-sweep system to automate memory management and prevent leaks. The language is characterized by a concurrent fiber-based execution model, allowing multiple non-blocking tasks to run simultaneously. It also functions as a JSON-native language, featuring built-in serialization tools to convert complex data structures to and from JSON format. The project includes a virtual machine and a compiler that transfor

JSONKit is an Objective-C library used for parsing, serializing, and manipulating JSON data. It functions as a JSON parser that converts text into native data structures and a serializer that transforms native objects into formatted JSON text. The library includes a gzip compression wrapper that compresses serialized JSON payloads to reduce network transfer sizes and automatically detects and decompresses gzip buffers before decoding. The toolset provides capabilities for JSON parsing and serialization, supporting customizable indentation, character escaping, and flexible comment handling.

Oils is a Unix shell interpreter and scripting language runtime that combines a modern shell language with POSIX and Bash compatibility. It functions as a structured data shell, integrating JSON and J8 formats to manage complex data without relying on string parsing. The system is distinguished by a C++ transpiled interpreter that converts a subset of Python source code into strongly typed C++ for high-performance execution. It features a garbage-collected typed runtime that supports prototype-based polymorphism, lexical closures, and reference-based variable mutation. To decouple shell logic

Typia is a compile-time code generator that transforms TypeScript type annotations into runtime validation, serialization, and schema functions without requiring decorators or separate schema files. It generates optimized validation and serialization code during TypeScript compilation, producing dedicated functions for each type that eliminate runtime schema objects for faster execution. The project extends this core capability into several integrated areas. It generates fully typed client SDKs from NestJS controller source code, keeping server and client types synchronized automatically. It

This is a Rust serialization library for converting data structures to and from JSON strings and byte streams. It is built as a framework within the Serde ecosystem, providing both a strongly typed parser for compile-time safety and a recursive value tree for manipulating JSON data without a predefined schema. The project supports both typed and untyped processing. It can map JSON data into specific Rust types for schema conformity or parse input into a flexible, schemaless representation. It also includes macro-based utilities for the dynamic construction of JSON objects.

kafka-python is a pure-Python client library for Apache Kafka that implements the Kafka wire protocol directly, without any native bindings or JVM dependencies. It provides the core capabilities of a Kafka client: producing messages to topics, consuming records from topics, and administering cluster resources such as topics and partitions, all through a Pythonic API or command-line tools. The library distinguishes itself through its comprehensive support for advanced Kafka features. It includes an asynchronous producer with background batching for throughput, a consumer group rebalance protoc

This is a JavaScript library for parsing and serializing JSON data, with a particular focus on handling objects that contain circular references. It provides a standard JSON parser that reads text and reconstructs JavaScript values without using the eval function, guarding against code injection, alongside a standard serializer that converts objects into JSON strings for data interchange. The library distinguishes itself by offering specialized encoding and decoding for cyclical object graphs. It can serialize objects with circular references by replacing repeated object paths with JSONPath s

This project is a suite of tools for generating encoded shell commands and network listener configurations used in offensive security operations. It provides a collection of command generators for various shells and listeners to establish remote access during security penetration tests. The tool features a reverse shell payload generator that creates encoded command strings and a network listener command generator that produces the server-side syntax needed to accept incoming network connections. It includes a Base64 command encoder to transform shell commands into encoded strings to bypass s

r2 is a JavaScript HTTP client library and asynchronous request library used for executing network calls. It provides a runtime-agnostic network layer that abstracts underlying HTTP implementations to ensure consistent behavior across different JavaScript execution environments. The library functions as a JSON API client, automatically parsing response bodies and formatting outgoing payloads. It utilizes a promise-based interface to manage the lifecycle of HTTP requests and responses. The project covers REST API integration and HTTP header management, allowing users to attach custom key-valu

Joint is a JavaScript library for building interactive visual diagrams and flowcharts using Scalable Vector Graphics. It provides a programmable environment for creating an interactive SVG canvas with integrated support for zooming, panning, and touch gesture controls. The framework includes a component system for defining custom shapes and programmatic elements within a vector-based coordinate system. It features a JSON-based diagram serializer for saving and loading diagram states, as well as automated layout algorithms and relationship mapping to render nodes and edges. The library covers

go-restful is a framework for building RESTful web services in Go. It functions as a toolkit for managing API endpoints, providing a request router that maps incoming HTTP requests to handler functions using path parameters and custom URL patterns. The framework includes a data conversion layer that transforms Go structures into JSON or XML formats for request and response bodies. It also provides a system for organizing related web services into containers to manage endpoint prefixing and shared configuration. The project covers request lifecycle management through middleware filters for va

Ion is an asynchronous HTTP client library for Android that handles network requests, JSON parsing, image loading, and file downloads. It provides a fluent builder pattern for constructing requests and supports automatic JSON deserialization into Java objects using Gson, along with in-memory image caching and multipart form-data encoding. The library distinguishes itself through its support for request cancellation via Future objects, allowing individual or bulk cancellation of in-flight requests to avoid wasted bandwidth and stale callbacks. It also includes proxy-aware request routing for d

This project is a Git-based AI session tracker and context manager designed to record AI agent interactions, transcripts, and tool usage directly into Git repositories. It functions as a system for capturing and indexing the reasoning behind code changes, linking AI prompts and responses to specific code commits to preserve developer intent. The tool distinguishes itself by using Git as a primary storage layer for session metadata, utilizing shadow branches and checkpoints to track agent state without polluting the main commit log. It includes specialized capabilities for auditing AI contribu

grpc-rust is a native gRPC framework for Rust designed for building high-performance remote procedure call clients and servers. It provides an asynchronous communication stack and a protocol buffers implementation for encoding, decoding, and generating type-safe code from service definitions. The project enables the implementation of unary and bi-directional data streaming over the HTTP/2 protocol. It includes specialized support for gRPC-Web integration, allowing browser-based clients to communicate with services through protocol translation. The infrastructure covers a broad range of distr

Superjson is a lossless JSON serialization library and data transcoder. It converts complex JavaScript and TypeScript data types into strings and metadata to ensure that type identity is preserved during data transfer. The library preserves non-native types such as Dates, Maps, and Sets by splitting values into a JSON-compatible payload and a separate map of type-specific metadata. It utilizes a registry-based mapping system that allows for the definition of custom type handlers to manage third-party data types during serialization and deserialization. This utility supports cross-process dat

This project is a .NET implementation of the gRPC framework, providing a system for executing functions on remote servers as if they were local calls. It serves as a high-performance remote procedure call (RPC) framework that utilizes HTTP/2 for service connectivity and binary communication protocols to ensure efficient data exchange. The implementation includes a gRPC-Web proxy, which acts as a translation layer to enable browser-based applications to communicate with gRPC services through web-compatible requests. It further supports the creation of HTTP/2 service meshes to connect distribut

Notifire is a multi-channel notification infrastructure designed to route and dispatch alerts across email, SMS, push, and chat providers through a unified interface. It functions as an agent communication gateway that normalizes inbound and outbound messages between chat platforms and AI agents for consistent data processing. The system includes a notification workflow engine that uses branching conditions and batching capabilities to design delivery sequences and reduce user fatigue. It also provides a pre-built notification center component, allowing web applications to embed a real-time i

tcell is a Go terminal user interface library and framework for building cell-based applications. It functions as a terminal emulator backend and input processor, utilizing a change-based diffing engine to manage screen state and efficiently render updates. The project is distinguished by its pluggable backend abstraction, which allows terminal interfaces to be rendered across physical terminals or compiled into WebAssembly for web browser display. It provides a virtual screen simulation to enable programmatic event injection and output inspection for automated application testing. Its capab

Rudder Server is a customer data platform and event routing pipeline designed to collect, transform, and route customer event data from various sources to data warehouses and business tools. It functions as a customer identity resolver, linking identifiers from multiple sources to build a unified identity graph and comprehensive behavioral customer profiles. The system differentiates itself through reverse ETL capabilities, which push processed customer segments and audiences from data warehouses back into operational third-party applications. It also provides a containerized data plane for K

pyJianYingDraft is a Python library used to programmatically generate and manipulate video project files compatible with CapCut and Jianying editors. It functions as an automation tool for creating video editing drafts, allowing users to assemble montage pipelines through code. The project enables the creation of video drafts by replacing media assets and updating text within existing project templates. It provides a programmatic interface to manage dynamic video templates, which preserves original formatting and timing while swapping specific materials. Capabilities include the management o

Stack Auth is an open-source authentication and authorization platform that provides pre-built UI components, OAuth integration, team management, and session handling for web applications. It offers a complete authentication lifecycle covering sign-in, sign-up, session management, password recovery, and multi-factor security, with support for passkey authentication and OAuth providers including Google, GitHub, and Apple. The platform includes a team-based permission system with role-based access control, allowing users to be organized into teams with granular permissions for membership manage