square/wire

Wire is a multiplatform Protocol Buffers library that generates code and provides runtime serialization for Java, Kotlin, and Swift. It includes a compiler and Gradle plugin to produce type-safe models and gRPC client stubs, supporting both Proto2 and Proto3 schemas. The system features a comprehensive gRPC client implementation with streaming support and integrates with JSON libraries like Gson and Moshi for serialization.

33 changes.

The project underwent a comprehensive migration to Kotlin Multiplatform, rewriting the compiler, runtime, and schema modules in Kotlin to support JVM, JS, and Native targets. This period introduced extensive new code generation features for Kotlin and Java, alongside native support for Swift and gRPC, while establishing a robust Gradle plugin and JSON serialization adapters.

69 changes.

The project significantly expanded its multiplatform support by adding JavaScript and Kotlin/Native targets to the schema library and refactoring the gRPC client for cross-platform compatibility. Concurrently, a new Swift runtime and code generator were introduced, providing full serialization, decoding, and well-known type support for iOS and macOS environments. This period also saw the establishment of public API baselines for core modules and the addition of comprehensive test suites to validate cross-language interoperability.

13 changes.

The project extended Wire's runtime and gRPC client support to non-JVM platforms, including Kotlin/Native, Kotlin/Wasm, and WASI, while adding Swift opaque type generation. This period focused heavily on comprehensive test coverage, introducing multiplatform validation suites, JSON adapter tests, and specific checks for Java/Kotlin interop and edge cases to ensure cross-platform consistency.

This change introduces a new sample app that demonstrates how to use build variants to include different Protobuf message definitions. The sample includes a shared \common.proto\ in the main source set, a \debug.proto\ defining a \DebugType\ message, and a \release.proto\ defining a \ReleaseType\ message. It also provides unit tests (\DebugUnitTest\, \ReleaseUnitTest\) that verify the correct types are available in their respective build variants and absent in others, illustrating how to isolate variant-specific code generation.

samples/android-app-variants-sample · high confidence

The wire-benchmarks module now includes JMH microbenchmarks that compare the performance of Wire's encoding and decoding against Google Protobuf for both Proto2 and Proto3 schemas. The new benchmarks cover a comprehensive 'AllTypes' message (including all scalar types, maps, oneofs, and extensions) and a realistic 'EmailSearchResponse' message, providing developers with performance data for serialization and deserialization across both libraries.

wire-benchmarks · high confidence

A new Java-only Android sample has been added to the \samples/android-app-java-sample\ directory, providing a reference implementation for developers using Java on Android. This sample includes a \MainActivity\ that instantiates a \SomeText\ protobuf message (defined in \text.proto\) and displays its value in the UI, demonstrating how to integrate Wire-generated Java classes into an Android app. The entry also includes the corresponding \android-lib-java-sample\ library module containing the \SomeObject\ class and shared protobuf definitions.

samples/android-app-java-sample · high confidence

A new Kotlin-based Android sample has been added to the repository, consisting of an app module and a library module. The app module demonstrates a basic Android activity that displays a protobuf-generated message, while the library module provides a Kotlin class that utilizes the generated protobuf types. This sample serves as a reference implementation for integrating Wire with Kotlin in an Android environment.

samples/android-app-kotlin-sample · high confidence

A new sample project for Kotlin/Native has been added to demonstrate using Protobuf Builders. The sample includes a proto definition for a Person message with nested phone number details and a Kotlin entry point that constructs a Person instance using the Builder pattern and prints the result.

samples/native · high confidence

This change introduces a new \WireJsonAdapterFactory\ for the Moshi library, enabling users to serialize and deserialize Wire \Message\ types, \WireEnum\ values, and \AnyMessage\ wrappers to and from JSON. The implementation includes specific adapters for handling \FieldMask\ types and supports configuration options such as \preservingProtoFieldNames\ to keep original protobuf field names in the JSON output and \writeIdentityValues\ to force writing of default values. This allows applications using Moshi to seamlessly exchange Wire protocol buffer data in JSON format.

wire-moshi-adapter/src · high confidence

The Wire Swift runtime now includes generated model types for the protobuf well-known types \Duration\ and \Timestamp\, as well as \ExtensionRangeOptions\ and \OneofOptions\. These types provide native Swift structs with \seconds\ and \nanos\ fields (for time types) and conform to \Proto3Codable\ or \Proto2Codable\ for encoding and decoding, enabling users to serialize and deserialize these standard protocol buffer types directly in Swift applications.

wire-runtime-swift/src/main/swift/wellknowntypes · high confidence

The samples/wire-grpc-sample/server module now includes a complete gRPC server implementation for the Whiteboard demo. This adds a Kotlin-based server entry point (MiskGrpcServer) that configures and runs the application using the Misk framework, including a WhiteboardGrpcAction that handles bidirectional streaming for drawing commands and updates, along with the necessary gRPC service definition (whiteboard.proto), dependency injection module (WhiteboardGrpcModule), and SSL/TLS configuration for secure communication on port 8443.

samples/wire-grpc-sample/server · high confidence

A new playground module has been added to facilitate debugging and development of the Wire Gradle plugin. This module includes a sample \MyListener\ implementation of the \EventListener\ interface to monitor Wire execution phases, along with sample Protobuf definitions (\squareup/player.proto\) for testing purposes.

wire-gradle-plugin-playground · high confidence

The minSdk 21 Kotlin sample app has been added to demonstrate Wire serialization on older Android versions. The sample includes a minimal Android application that deserializes a protobuf message using Moshi and WireJsonAdapterFactory, along with corresponding Android tests to verify the deserialization behavior.

samples/android-app-kotlin-minsdk-sample · high confidence

The samples/multi-target location now includes a Kotlin source file and a Protocol Buffers definition that demonstrate building and using a Person message with nested PhoneNumber data. This sample allows users to see how protobuf-generated code integrates with Kotlin/Native targets, specifically showing the construction of a Person object with a phone number and printing the result.

samples/multi-target · high confidence

The Wire runtime now includes a new \decode\ extension function for \ProtoAdapter\ specifically for Darwin (iOS/macOS) targets. This addition allows users to directly decode protobuf messages from \NSData\ objects, handling the necessary memory copying from Objective-C types to Kotlin byte arrays internally.

wire-runtime/src/darwinMain · high confidence

A new ParsingTester utility has been added to the wire-schema module, allowing users to recursively traverse a directory and attempt to parse all .proto files within it to verify syntax correctness. This tool provides immediate feedback on parsing failures, helping developers identify and fix issues in their protocol buffer definitions before integration.

wire-schema/src/jvmTest/kotlin/com/squareup/wire/schema/internal/parser · high confidence

The Wire runtime now supports the WebAssembly System Interface (WASI) target. This change introduces a new platform-specific implementation file (-Platform.kt) within the wasmWasiMain source set, providing the necessary actual implementation for the JsName annotation to ensure compatibility with WASI environments.

wire-runtime/src/wasmWasiMain · high confidence

Added new sample schema handlers in the \wire-schema-tests\ module to demonstrate custom schema processing: \ErrorReportingSchemaHandler\ for validating field naming patterns, \LogToFileHandler\ for writing generation logs to disk, \LogToWireLoggerHandler\ for logging handled artifacts, and \MarkdownHandler\ for generating Markdown documentation from schema types and services, along with their corresponding unit tests.

wire-schema-tests/src/commonTest · high confidence

The gRPC client library now includes a shared \nonJvmMain\ source set containing \actual\ implementations for core client components such as \GrpcClient\, \GrpcRequest\, \GrpcResponse\, and \GrpcRequestBody\. These stubs provide the necessary API surface for non-JVM targets (including the newly added \wasmJs\ support), though many methods currently throw \UnsupportedOperationException\ or return \TODO\ placeholders, indicating that full runtime functionality for these platforms is still under development.

wire-grpc-client/src/nonJvmMain · high confidence

The Wire schema library now supports compilation on the JavaScript platform. This change introduces platform-specific implementations for core utility functions (such as character digit checking, string lowercasing, and mutable queue operations) in the \wire-schema\ module, allowing users to utilize Wire's schema processing capabilities in JavaScript environments.

wire-schema/src/jsMain/kotlin/com/squareup/wire/schema/internal · high confidence

The Wire protocol buffer compiler now generates Swift code for opaque types, as demonstrated by the new \OuterOpaqueType.swift\ file. This generated code defines \OuterOpaqueType\ along with its nested \InnerOpaqueType1\ and \InnerOpaqueType2\ structs, providing full serialization and deserialization capabilities via \ProtoMessage\ and \Codable\ protocols. Users can now utilize these generated types for encoding and decoding protocol buffer messages containing opaque data fields in Swift applications.

wire-tests-swift/opaques · high confidence

This change introduces the foundational structure for the Swift Wire runtime library. It adds a README with instructions for development using Xcode, CocoaPods, and command-line Gradle tasks, including performance testing guidelines. It also includes a .gitignore to exclude generated Swift test files and a Ruby helper script (pod\_helpers.rb) that manages versioning for CocoaPods publishing, allowing configuration of the Maven host URL via environment variables.

wire-runtime-swift · high confidence

The repository is initialized with foundational configuration and documentation files, including an .editorconfig for consistent code formatting, a .gitignore for build artifacts, and standard project files like LICENSE.txt, README.md, and RELEASING.md. A mkdocs.yml configuration is added to support the project website, and a gen-tests.gradle.kts script is introduced to automate the generation of Swift test protos. Additionally, a SECURITY.md policy is established to guide vulnerability reporting via Bugcrowd.

(repo-wide) · high confidence

The wire-grpc-client module now includes internal components for handling gRPC message framing and compression. New files in the \com.squareup.wire.internal\ package introduce \GrpcDecoder\ and \GrpcEncoder\ sealed classes to manage identity and gzip encoding strategies, alongside \GrpcMessageSink\ and \GrpcMessageSource\ classes that implement the gRPC length-prefixed message format over HTTP/2 streams. These components rely on platform-specific expectations defined in \platform.common.kt\ for gzip stream adaptation and call cancellation, providing the foundational logic for serializing and deserializing protobuf messages within the gRPC client.

wire-grpc-client/src/commonMain/kotlin/com/squareup/wire/internal · high confidence

Wire now includes a new Swift generator that produces Swift source files from protocol buffer schemas. This change adds the SwiftGenerator class, which handles the creation of Swift types (messages, enums, oneofs) and their encoding/decoding logic, and the SwiftSchemaHandler class, which orchestrates the generation process by iterating over schema types and writing the resulting Swift files to the output directory. Users can now generate Swift code alongside existing Java, Kotlin, and other language outputs.

wire-swift-generator/src/main · high confidence

Adds the Wire Gradle plugin, enabling users to configure and run protobuf code generation directly within their Gradle builds. The plugin introduces a \wire\ DSL extension for defining source paths, tree-shaking roots and prunes, and output targets (Java, Kotlin, or proto), and registers a \generateProtos\ task that executes the Wire compiler to produce the specified code.

wire-gradle-plugin/src/main/kotlin/com/squareup/wire/gradle · high confidence

A new Gradle settings plugin (WireSettingsPlugin) has been added to the build-support module. When applied to the root settings.gradle via includeBuild, it automatically injects the WireBuildPlugin into all subprojects, ensuring consistent application of common configurations such as Spotless formatting, testing setups, Android/Kotlin defaults, and publishing rules without requiring individual project-level boilerplate.

build-support · high confidence

The wire-reflector module now implements the gRPC Server Reflection API (v1alpha), allowing clients to introspect the schema of a Wire service at runtime. This change adds the \SchemaReflector\ class, which processes reflection requests to list registered services, retrieve file descriptors by name or symbol, and query extension numbers. The implementation includes the standard \grpc/reflection/v1alpha/reflection.proto\ service definition and is verified by interop tests against gRPCurl expectations for both Proto2 and Proto3 schemas.

wire-reflector · high confidence

The Wire Swift runtime now includes a new \ProtoCodable\ subsystem that provides the core infrastructure for serializing and deserializing Protocol Buffer messages. This change adds the \ProtoDecoder\ and \ProtoEncoder\ classes, along with \ProtoReader\ and \ProtoWriter\ for low-level stream handling, enabling the conversion of in-memory Swift structs to and from binary protobuf data. The implementation introduces the \ProtoCodable\, \ProtoDecodable\, and \ProtoEncodable\ protocols, which are adopted by standard Swift types (such as \Bool\, \String\, \Int32\, \Int64\, \Float\, \Double\, and \Data\) to support native encoding and decoding. It also defines \FieldWireType\ and \ProtoIntEncoding\ to manage protobuf wire types and integer encoding strategies (variable, fixed, and signed).

wire-runtime-swift/src/main/swift/ProtoCodable · high confidence

Wire now provides built-in runtime classes for the \google.protobuf.Any\ and \FieldMask\ well-known types. Users can wrap and unwrap arbitrary messages using \AnyMessage.pack()\ and \AnyMessage.unpack()\, and manipulate field subsets via the new \FieldMask\ class. These additions are supported by new common runtime infrastructure, including \ProtoReader32\ for optimized decoding on Kotlin/JS and \expect\ declarations for platform-specific \Duration\ and \Instant\ types.

wire-runtime/src/commonMain/kotlin/com/squareup/wire · high confidence

The wire-schema module now exposes a \WireLogger\ interface, allowing users to plug in custom logging implementations to monitor schema processing activities. This interface captures key events such as when artifacts are handled or skipped by schema handlers, and when pruning rules (roots, prunes, includes, excludes) are defined but not applied during schema analysis. A default \NONE\ implementation is provided for users who do not require custom logging behavior.

wire-schema/src/commonMain/kotlin/com/squareup/wire · high confidence

Wire-schema now runs on Kotlin/Native targets. This change introduces native-specific implementations for core schema-loading components, including the file system loader, multimap utilities, profile handling, and root resolution. Users on native platforms can now load .proto files from directories and individual files, though archive formats (ZIP/JAR) are not supported and require manual addition to the proto path.

wire-schema/src/nativeMain · high confidence

A new GrpcDispatcher class is now available in the wire-grpc-mockwebserver module, allowing users to serve gRPC calls using MockWebServer over HTTP/2. This dispatcher can be configured with a list of Wire-generated gRPC services and delegates non-gRPC requests to a standard MockWebServer dispatcher, enabling easier testing of gRPC clients without needing a real server. The implementation currently supports unary calls but does not support streaming calls.

wire-grpc-mockwebserver · high confidence

Wire now provides a Gson-based JSON integration, allowing users to serialize and deserialize Wire protocol buffer messages using the GSON library. By registering the new WireTypeAdapterFactory with a GsonBuilder, applications can encode and decode any Wire Message type, including extensions and unknown fields, in a format compatible with protobuf-java-format. The integration also supports special types like AnyMessage and FieldMask, and offers options to preserve proto field names or write identity values.

wire-gson-support/src · high confidence

The Kotlin generator now exposes several new configuration options to control code style and behavior. Users can choose how enums are generated via \enumMode\ (standard enum classes or sealed classes), how oneof fields are structured via \oneofMode\ (flat, boxed, or sealed classes), and how RPC calls are generated via \rpcCallStyle\ (suspending or blocking). Additional options include \mutableTypes\ for mutable message classes, \makeImmutableCopies\ to control collection immutability, and \emitProtoReader32\ for Kotlin/JS optimization.

wire-kotlin-generator/src/main · high confidence

The Wire Swift runtime now includes a new Codable module that enables native Swift \Codable\ serialization for Protobuf messages. This adds support for encoding and decoding \Duration\ and \Timestamp\ types, handles \ProtoEnum\ values with configurable strategies (encoding as strings or integers, decoding with error or nil-return policies), and provides property wrappers for \ProtoArray\ and \ProtoMap\ to correctly serialize repeated fields and map entries. It also implements \StringCodable\ support for \Data\ (using Base64/URL-safe Base64) and numeric types, along with utilities for key name encoding (camelCase vs. field name) and default value handling.

wire-runtime-swift/src/main/swift/Codable · high confidence

Added a new Android sample application that demonstrates real-time collaborative drawing using gRPC. The client establishes a bidirectional streaming connection to a server, allowing users to draw points on a shared whiteboard view and receive live updates from other clients. The implementation includes a custom UI for the whiteboard, an SSL/TLS configuration for secure communication, and coroutine-based handling of the gRPC streams.

samples/wire-grpc-sample/client/src/main/java · high confidence

Wire now supports a new set of custom protobuf options defined in \wire/extensions.proto\ that allow fine-grained control over code generation. Users can annotate fields with \since\ and \until\ to manage versioned availability, and use \use\_array\ (as a boolean) to optimize JVM runtime performance by storing repeated scalar values in primitive arrays instead of boxed objects. Additionally, \enum\_mode\ allows per-enum selection between Kotlin enum classes and sealed classes, while \constant\_since\ and \constant\_until\ enable versioning for individual enum constants. A new \wire\_package\ file option is also available to override the target JVM package for generated classes, helping to avoid conflicts when mixing Wire and Protobuf code generation.

wire-schema/src/jvmMain/resources/wire · high confidence

A new sample application demonstrating Protobuf serialization with the Wire library has been added under samples/simple-sample, including the Dinosaur and Period protocol buffer definitions and a Java client that encodes and decodes dinosaur data. Additionally, a configuration class for the wire-grpc-sample server has been introduced to define the web server settings using the Misk framework.

samples/simple-sample, server · high confidence

The gRPC client now includes new internal implementations for handling streaming calls: RealGrpcStreamingCall, RealGrpcClientStreamingCall, RealGrpcServerStreamingCall, and BlockingMessageSource. These classes provide the underlying mechanics for duplex, client-streaming, and server-streaming RPCs, utilizing OkHttp callbacks and Kotlin coroutines to manage request/response channels and message sources. Additionally, a platform-specific abstraction (platform.kt) is introduced to handle JVM-specific details like gzip encoding and exception suppression, ensuring the streaming logic is correctly wired to the underlying HTTP transport.

wire-grpc-client/src/jvmMain/kotlin/com/squareup/wire/internal · high confidence

The Swift runtime now includes four new property wrappers in the \propertyWrappers\ module to support generated code: \CopyOnWrite\ enables efficient heap allocation and copy-on-write semantics for large value types to prevent stack overflow; \Indirect\ provides an indirect enum wrapper for recursive types, ensuring correct memory layout for cycles; \ProtoDefaulted\ applies protocol-specified default values (such as zero for numeric types) to optional fields; and \CustomDefaulted\ allows fields to use explicitly defined default values. These wrappers collectively improve performance, memory safety, and spec compliance for Swift-generated protobuf messages.

wire-runtime-swift/src/main/swift/propertyWrappers · high confidence

Wire introduces new internal classes to improve schema integrity and code generation safety. ClaimedDefinitions and ClaimedPaths now track which schema types, members, and generated file paths have been handled by schema handlers, preventing duplicate processing and file collisions. A new CycleChecker validates that proto schemas do not contain import or package cycles, ensuring compatibility with tools like protoc and the Go compiler. Additionally, EmittingRules provides a robust system for defining and matching include/exclude patterns for code generation, while EnclosingType supports empty message types that only hold nested types.

wire-schema/src/commonMain/kotlin/com/squareup/wire/schema · high confidence

The wire-test-utils module now includes a set of new helper functions to standardize testing across platforms. SchemaHelpers adds a convenience method to retrieve a ProtoAdapter for a message type, while files.kt provides platform-aware path handling and file listing utilities. New JVM-specific helpers include Json.kt for comparing JSON values, SchemaHelpersJvm for adding local files to a schema builder, and filesJvm for writing files and ZIP archives to a virtual file system. Additionally, UnwantedValueStripper is introduced to normalize protobuf descriptors by stripping options and defaults, ensuring consistent test comparisons.

wire-test-utils · high confidence

The Swift runtime now includes implementations for several google.protobuf Well-Known Types, allowing users to work with \AnyMessage\ (wrapping arbitrary messages), \FieldMask\ (for specifying field paths), \Struct\ and \ListValue\ (for dynamic JSON-like data), and \Value\ (for generic JSON values). Additionally, the runtime introduces the \ProtoExtensible\ protocol and \ExtensibleUnknownFields\ type, enabling messages to store and parse extension fields with memoized decoding, replacing the previous raw \Data\-based unknown fields storage.

wire-runtime-swift/src/main/swift · high confidence

The Wire runtime now supports non-JVM targets (such as Kotlin/Native and Kotlin/Wasm) by introducing platform-specific implementations for core serialization components. This change adds \actual\ classes for \Duration\ and \Instant\ handling, implements the \EnumAdapter\ for enum serialization, and provides the foundational \Message\ and \ProtoAdapter\ classes required for encoding and decoding protocol buffers on these platforms. Additionally, platform-specific utility code in \internal/-Platform.kt\ supplies necessary annotations and helper functions, enabling the library to function outside the JVM ecosystem.

wire-runtime/src/nonJvmMain · high confidence

The wire-schema module now compiles to JavaScript, enabling schema loading and validation in browser or Node.js environments. This addition introduces JS-specific implementations for core components: CoreLoader (which throws an error if file loading is attempted, requiring manual proto path configuration), Multimap, Profile, Roots (which explicitly excludes .zip/.jar archive support), and SchemaLoader. Users can now integrate Wire's schema capabilities into JavaScript-based tooling, though they must handle file loading manually and cannot rely on archive-based proto sources.

wire-schema/src/jsMain/kotlin/com/squareup/wire/schema · high confidence

The Wire Swift generator now exposes its core public APIs, allowing users to programmatically access the SwiftGenerator for type generation and the SwiftSchemaHandler for schema processing. This includes helper methods in the SwiftGenerator companion object for checking built-in types, extensibility, and heap allocation, as well as safe name resolution utilities.

wire-swift-generator/api · high confidence

This change introduces the \wire-grpc-client.api\ file, which establishes the public binary compatibility contract for the Wire gRPC client library. It defines the core interfaces and classes available to users, including \GrpcCall\, \GrpcClient\, \GrpcStatus\, and various streaming call types (\GrpcClientStreamingCall\, \GrpcServerStreamingCall\, \GrpcStreamingCall\). It also exposes helper functions in \GrpcCalls\ and extension functions in \GrpcStreamingCallExtensionsKt\ for coroutine-based streaming, ensuring that these public APIs are tracked for backward compatibility.

wire-grpc-client/api · high confidence

The \wire-kotlin-generator\ module now exposes its public API surface, defining the configuration enums and generator classes used to control code generation. Users can configure \EnumMode\ (switching between \ENUM\_CLASS\ and \SEALED\_CLASS\), \OneofMode\ (supporting \BOXED\, \FLAT\, and \SEALED\_CLASS\), and \RpcCallStyle\ (choosing between \BLOCKING\ and \SUSPENDING\ calls). The \KotlinGenerator\ and \KotlinSchemaHandler\ classes are now part of the public contract, allowing integration with these specific generation behaviors.

wire-kotlin-generator/api · high confidence

The \wire-java-generator/api\ module now publishes its public API definitions, exposing the \JavaGenerator\ and \JavaSchemaHandler\ classes. This change makes the core Java code generation interfaces and handlers available for external inspection or integration, reflecting the underlying implementation details such as the use of Palantir's JavaPoet for code generation.

wire-java-generator/api · high confidence

The public API surface for the Gson support and Moshi adapter modules is now explicitly defined. For Gson, the \AnyMessageTypeAdapter\ and \WireTypeAdapterFactory\ classes are exposed, including factory methods and the \plus\ operators for adding custom proto adapters. For Moshi, the \WireJsonAdapterFactory\ and the \redacting\ utility function are published, enabling users to integrate Wire's JSON serialization with Moshi and apply redaction rules.

wire-gson-support/api, wire-moshi-adapter/api · high confidence

The public API for the Wire compiler has been expanded to expose granular control over Kotlin code generation. Users can now configure \KotlinTarget\ with new options including \EnumMode\, \OneofMode\, \RpcCallStyle\, \RpcRole\, \EscapeKotlinKeywords\, \BoxOneOfsMinSize\, and \SingleMethodServices\. Additionally, the API exposes \ProtoReader32\ support for Kotlin/JS, mutable message generation capabilities, and the ability to pass custom options and schema handler factories via \CustomTarget\. These changes allow users to fine-tune generated Kotlin code behavior and extend the compiler with custom schema handling logic.

wire-compiler/api · high confidence

The public API for the Wire Gradle plugin is now exposed via the \wire-gradle-plugin.api\ file, defining the stable interfaces for the \WirePlugin\, \WireExtension\, and output configuration classes (\KotlinOutput\, \JavaOutput\, \ProtoOutput\, \CustomOutput\). This change establishes the contract for configuring code generation targets, managing source paths, and setting options such as mutable types, explicit streaming calls, and keyword escaping within the Gradle DSL.

wire-gradle-plugin/api · high confidence

The public API surface for the Wire runtime is now defined, introducing the \FieldMask\ class for managing field selection paths and the \AndroidMessage\ class to enable Parcelable serialization for Android applications. The API also exposes the \AnyMessage\ type for handling Google's Any protobuf type, along with standard adapters for primitives, durations, and instants, establishing the baseline contract for the library's serialization capabilities.

wire-runtime/api · high confidence

Internal schema processing components—including the schema loader, linker, DAG cycle checker, profile parser, schema encoder, and type mover—have been migrated to the common module. This refactoring enables these core schema analysis and encoding capabilities to be shared across different target platforms (such as JVM and JS) within the Wire library.

wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/internal · high confidence

The internal utility classes and functions in \wire-runtime/src/commonMain/kotlin/com/squareup/wire/internal\—including \Internal\, \RuntimeMessageAdapter\, \MessageBinding\, \FieldOrOneOfBinding\, and primitive list wrappers like \IntArrayList\ and \DoubleArrayList\—have been consolidated into the common source set. This change centralizes the core serialization and binding logic, ensuring these internal components are available across all Kotlin Multiplatform targets (JVM, Native, JS) rather than being platform-specific.

wire-runtime/src/commonMain/kotlin/com/squareup/wire/internal · high confidence

A new build script (.buildscript/prepare\_mkdocs.sh) has been added to streamline the creation of the project's documentation website. This script executes the Gradle task 'dokkaGenerateHtml' to produce HTML-based API documentation, replacing previous formats that lacked necessary CSS for indexes. It then copies essential project files, such as the CHANGELOG and CONTRIBUTING guides, into the MkDocs documentation directory structure, ensuring the site is ready for deployment.

.buildscript · high confidence

The Webpack configuration for the wire-runtime now explicitly disables the fallback to the Node.js 'os' module. This prevents the bundler from including Node.js-specific polyfills for the operating system module, which is appropriate for browser-based environments where this module is not available.

wire-runtime/webpack.config.d · high confidence

The generated Swift message types in the Wire test suite now implement the \ProtoDefaultedValue\ protocol, providing a static \defaultedValue\ property that returns an empty instance of the struct. This change ensures that generated models align with the protocol buffer specification for default values, allowing consumers to easily access a zero-initialized state for messages like \ContainsDuration\ and \ContainsTimestamp\.

wire-tests-proto3-swift · high confidence

The Wire Gradle plugin now uses a dedicated logger (GradleWireLogger) to control console output, ensuring that file-emission messages are no longer logged during normal operation while still reporting warnings for unused tree-shaking roots or prunes. Additionally, the plugin now detects the presence of the Kotlin Gradle plugin and, when available, forces dependency resolution to the JVM variant to ensure correct artifact selection for Kotlin projects.

wire-gradle-plugin/src/main/kotlin/com/squareup/wire/gradle/internal · high confidence

The JVM runtime module now includes platform-specific implementations for core runtime behaviors, such as using Java's Collections for unmodifiable lists and maps, and provides dedicated JSON formatters for Duration, Instant, FieldMask, and Enum types. Additionally, the internal reflection utilities have been updated to support SealedOneOf bindings, allowing the runtime to correctly handle and serialize sealed class oneof fields alongside standard proto oneofs.

wire-runtime/src/jvmMain/kotlin/com/squareup/wire/internal · high confidence

The JVM-specific gRPC client implementation has been restructured to directly alias core HTTP types (headers, URLs, requests, responses) to their OkHttp equivalents and introduces explicit support for client and server streaming calls. This change also improves timeout handling by propagating request timeouts as the 'grpc-timeout' header and refines the serialization of timeout values to ensure they fit within the gRPC wire format limits.

wire-grpc-client/src/jvmMain/kotlin/com/squareup/wire · high confidence

The Wire runtime for the JVM target is now implemented in Kotlin, providing the concrete \actual\ classes for the multiplatform protocol buffer library. This includes the core \Message\ and \ProtoAdapter\ implementations, platform-specific adapters for \Duration\ and \Instant\ (mapping to \java.time\), and specialized support for Android via the new \AndroidMessage\ class which enables \Parcelable\ serialization. The JVM build also introduces \KotlinConstructorBuilder\ to support mutable message builders and uses reflection via \RuntimeEnumAdapter\ for enum handling, ensuring the JVM runtime is fully compatible with the common multiplatform API.

wire-runtime/src/jvmMain/kotlin/com/squareup/wire · high confidence

The wire-schema module now includes JVM-specific implementations for core schema operations. Schema loading is handled by a new SchemaLoader that wraps the common loader and exposes configuration options like permitPackageCycles, opaqueTypes, and loadExhaustively. Built-in .proto files are loaded via CoreLoader using Okio's resource filesystem. Profile mapping for Java and Kotlin targets is implemented in Profile, and adapter constants are parsed via AdapterConstant. File system roots (directories, .proto files, and archives) are resolved in Roots using Okio APIs. Additionally, serializable factory classes for custom event listeners (EventListeners) and loggers (WireLoggers, including a built-in EmptyWireLoggerFactory) are provided to support Gradle caching and custom runtime behavior.

wire-schema/src/jvmMain/kotlin/com/squareup/wire/schema · high confidence

This change introduces JVM-specific internal utilities for the Wire schema module. It adds logic to map ProtoTypes to their corresponding Java/Kotlin adapters, including support for array types, and provides functions to validate package option values to ensure they form valid Java package names. Additionally, it implements UTF-32 BOM detection for file sources and defines platform-specific implementations for character and string utilities required by the JVM target.

wire-schema/src/jvmMain/kotlin/com/squareup/wire/schema/internal · high confidence

The Java generator now exposes a \JavaSchemaHandler\ that orchestrates code generation via the \SchemaHandler\ interface. This handler accepts configuration options for Android compatibility (\android\, \androidAnnotations\), compact mode (\compact\), and option emission (\emitDeclaredOptions\, \emitAppliedOptions\), then delegates to the \JavaGenerator\ to produce Java source files for types, services, and extensions. This change centralizes the generation workflow and allows the generator to be integrated into the schema processing pipeline more cleanly.

wire-java-generator/src/main · high confidence

The internal \.proto\ schema parser elements (such as \MessageElement\, \FieldElement\, \EnumElement\, \ProtoParser\, and \SyntaxReader\) have been moved to the \commonMain\ source set. This migration makes the schema parsing logic available for non-JVM targets, allowing the Wire library to parse and generate \.proto\ files in Kotlin Multiplatform projects beyond the JVM.

wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/internal/parser · high confidence

The Wire compiler now exposes granular configuration options for both Java and Kotlin code generation targets via the new \JavaTarget\ and \KotlinTarget\ classes. Users can now control specific behaviors such as RPC call styles (blocking vs. suspending), service interface structures (single-method vs. combined), and Kotlin-specific features like escaping keywords, enum/oneof representation modes, and mutable type generation. This allows for more precise customization of the generated source code to match project requirements without altering the underlying schema.

wire-compiler/src/main/java/com/squareup/wire/schema · high confidence

The Wire runtime now provides platform-specific actual implementations for the \JsName\ annotation in the JS and Native modules. For JavaScript, it uses the standard Kotlin/JS \JsName\ annotation, while for Native, it defines an empty placeholder annotation. This change supports the broader migration to a Hierarchical Multi-Platform Project structure by ensuring consistent annotation handling across different compilation targets.

wire-runtime/src/jsMain, wire-runtime/src/nativeMain · high confidence

In the wire\_message.proto file within the Kotlin extensions compatibility tests, the wire.since and wire.until options applied to enum values (WireEnum) have been renamed to wire.constant\_since and wire.constant\_until. This change distinguishes enum value versioning from field versioning, ensuring that the version constraints for enum constants are handled correctly by the Wire library.

wire-protoc-compatibility-tests/src/main/proto/squareup/proto3/kotlin/extensions · high confidence

The Wire Gradle plugin now uses a new \SourceRoots\ module to correctly register generated code for Kotlin Multiplatform and Android projects. For multiplatform projects, generated sources are now placed in \commonMain\ to ensure they are consumed by all targets, including Android. For Android projects, the plugin leverages the Android Variant API to register generated sources per variant, ensuring compatibility with KSP and preventing source duplication. This change improves build correctness for complex project structures.

wire-gradle-plugin/src/main/kotlin/com/squareup/wire/gradle/kotlin · high confidence

The Swift code generator has been updated to correctly handle protocol buffer definitions spread across multiple Swift modules. It now disambiguates types that share names in different modules (e.g., \Address\ in \module\_address\ vs. \module\_location\) by using fully qualified module-prefixed names (e.g., \module\_address.Address\) when referencing types from other modules. Additionally, it properly imports external modules, generates extension fields as computed properties on the parent message, and ensures that types conflicting with common Swift names (like \SortOrder\) are correctly qualified to avoid collisions.

wire-tests-swift/manifest · high confidence

The bundled Google protobuf schema files in wire-schema have been updated to the latest upstream versions. This includes new definitions for the \Any\ type (supporting \type\_url\ and \value\ fields) and the \FieldMask\ type (for specifying field subsets in API operations), alongside refreshed definitions for well-known types such as \DescriptorProto\ (now including Edition support), \Duration\, \Timestamp\, \Struct\, \Value\, \ListValue\, \Empty\, and primitive wrappers (\DoubleValue\, \StringValue\, etc.).

wire-schema/src/jvmMain/resources/google · high confidence

The \wire-golden-files\ module has been refreshed with new generated Kotlin code that demonstrates several recent Wire generator improvements. The files now include examples of mutable message types (e.g., \MutableHeader\, \MutablePayload\) which use mutable properties and lack builders, as well as sealed classes for oneofs (e.g., \BoxedOneOfs\) that provide accessors for the generated data classes. Additionally, the golden files cover edge cases such as large oneofs that require chunked redaction logic, opaque types, and proto3 options, ensuring the generated code compiles and behaves correctly under these specific configurations.

wire-golden-files · high confidence

The generated Swift types in this test module have been updated to reflect improvements in the Wire protocol buffer compiler. Messages now consistently implement the \ProtoExtensible\ protocol to support extension fields, and \unknownFields\ are handled with appropriate types (\UnknownFields\ or \ExtensibleUnknownFields\). Enum generation has been refined to correctly handle proto2 syntax, including the use of \Proto2Enum\ conformance, proper handling of negative enum values, and avoidance of identity value emission where appropriate. Additionally, the generated code now better manages naming collisions (such as oneofs named 'container' or 'self') and ensures correct import emission for parameterized types.

wire-tests-swift/no-manifest/src/main · medium confidence

The public API surface for the wire-schema module has been updated, primarily reflecting the ABI dump for Kotlin 2.4.10. This change includes the introduction of new internal tracking classes like ClaimedDefinitions and ClaimedPaths, the addition of an EmptyWireLoggerFactory for default logging, and structural adjustments to core schema types such as EnumType and EnclosingType. These updates ensure the schema module's public contracts remain consistent with the underlying Kotlin version and internal implementation details.

wire-schema/api · medium confidence

The wire-codegen-sample has been updated to generate Java service interfaces using Palantir's JavaPoet library instead of the previous implementation. This change introduces a new ServiceGenerator component that constructs API interfaces from Wire schema definitions, including support for RPC method signatures and documentation comments. The sample also includes corresponding tests verifying the generated interface structure.

samples/wire-codegen-sample · high confidence

The Wire compiler implementation in this package has been converted from Java to Kotlin, introducing a modernized command-line interface and new operational modes. Users can now perform a dry run to preview generated files without writing them to disk, and the compiler supports multiple output targets (Java, Kotlin, Swift) within a single command execution. The update also adds granular control over Kotlin code generation, including options for enum modes, oneof handling, and explicit streaming calls, alongside the ability to configure custom loggers and schema handlers via the CLI.

wire-compiler/src/main/java/com/squareup/wire · high confidence

The gRPC client library has been restructured to support Kotlin multiplatform, introducing platform-agnostic \expect\ declarations for core classes like \GrpcClient\, \GrpcRequest\, and \GrpcResponse\. This change adds explicit interfaces for client-side and server-side streaming calls (\GrpcClientStreamingCall\ and \GrpcServerStreamingCall\), deprecating the generic \GrpcStreamingCall\ for those specific use cases to improve type safety and structured concurrency support. Additionally, \GrpcException\ now exposes the gRPC URL and status details, and \GrpcStatus\ has been made serializable.

wire-grpc-client/src/commonMain/kotlin/com/squareup/wire · high confidence

Add proto3 Kotlin pizza compatibility test schema; Add test proto with enum constant named 'object'; Added API surface tests for SchemaBuilder and WireTestLogger; Added JVM-Kotlin interop test coverage; Added JVM-specific tests for SchemaBuilder; Added Java protobuf fixtures for comprehensive Wire testing; Added RouteGuide proto definition for gRPC testing; Added Swift runtime test protos for FieldMask, Struct, Any, and extensible fields; Added Swift tests for JSON serialization and copy-on-write behavior; Added generated Swift sample models for Dinosaur and Period; Added interop and round-trip tests for Duration, Timestamp, FieldMask, and Empty types; Added multiplatform test suite for Wire serialization and behavior; Added proto3 Kotlin compatibility test schemas; Added proto3 interop test schemas for compatibility validation; Added proto3 map type compatibility test; Added proto3 schema definitions for Empty, Structs, Wrappers, and optional fields; Added shared JSON serialization tests for Protobuf types; Added test coverage for Swift runtime encoding, decoding, and serialization features; Added test coverage for Wire schema internal components; Added test coverage for Wire serialization and JSON adapters; Added test coverage for Wire's gRPC client implementation; Added test coverage for schema linking, cycle detection, and WireRun execution; Added test fixtures for Wire dinosaur artifacts; Added tests for Duration, Instant, FieldMask, and ProtoReader/Writer behavior; Added tests for Java code generation and helper utilities; Added tests for Kotlin code generation with profile support; Added tests for ProtoReader32 decoding behavior; Added tests for Swift extension field accessors and FieldMask support; Added tests for Wire Gradle plugin output configuration and plugin behavior; Added tests for WireCompiler CLI options and error handling; Added tests for schema encoding and type migration; Added tests for schema location normalization, emitting/pruning rules, and SemVer comparison; Added unit tests for internal utility classes; Expanded integration tests for the Wire Gradle plugin; Expanded proto2 compatibility test schemas for Java and Kotlin; Expanded test coverage for Wire schema validation and serialization; New test utilities for multiplatform schema testing.

This change adds a Package.swift manifest to the project, enabling developers to integrate the Wire Swift runtime directly via Swift Package Manager alongside existing CocoaPods support. It also introduces a new build-support module that centralizes the Gradle build configuration, including the Wire build plugin and settings plugin, while updating the root build files and version catalogs to reflect these structural changes.

(dependencies) · high confidence

The Gradle wrapper configuration has been updated to use Gradle 9.7.1. This change ensures that builds will automatically download and use this specific version of the Gradle build tool, providing consistency across development environments and leveraging the features and performance improvements included in this release.

gradle/wrapper · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 33 → 57 (+24.1)
• Rubric changed (rubric-2026.08.15 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 82 → 82 (-0.1)
• Architecture 94 → 100 (+5.8)
• Maturity 39 → 47 (+7.9)
• Readiness 24 → 59 (+35.2)
• Security 22 → 61 (+38.5)

• Coverage not measured — test suite did not build
• Critical CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
• Critical CVE: [GHSA redacted] (kotlin-js-store/yarn.lock)
• Dimension evaluation failed
• Duplicated block (10 lines × 2) (wire-tests/wire-json-shared-kotlin-tests/com/squareup/wire/WireJsonTest.kt)
• Duplicated block (10 lines × 2) (wire-tests/wire-json-shared-kotlin-tests/com/squareup/wire/WireJsonTest.kt)
• Duplicated block (10 lines × 2) (wire-tests/wire-json-shared-kotlin-tests/com/squareup/wire/WireJsonTest.kt)
• Duplicated block (10 lines × 2) (wire-tests/wire-json-shared-kotlin-tests/com/squareup/wire/WireJsonTest.kt)
• Duplicated block (11 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (11 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/internal/Internal.kt)
• Duplicated block (12 lines × 2) (samples/wire-grpc-sample/client/src/main/java/com/squareup/wire/whiteboard/MainActivity.kt)
• Duplicated block (12 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (12 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (12 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (12 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (12 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/internal/Internal.kt)
• Duplicated block (12 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/internal/Internal.kt)
• Duplicated block (12 lines × 2) (wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/EmittingRules.kt)
• Duplicated block (12 lines × 2) (wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/PruningRules.kt)
• Duplicated block (13 lines × 2) (wire-kotlin-generator/src/main/java/com/squareup/wire/kotlin/KotlinGenerator.kt)
• …and 116 more

• ByteArrayProtoReader32.internalReadVarint32 (cognitive 22) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ByteArrayProtoReader32.kt)
• Change coupling: WireInput.kt ↔ WirePlugin.kt (wire-gradle-plugin/src/main/kotlin/com/squareup/wire/gradle/WireInput.kt)
• ClassTooLong: ProtoParser (wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/internal/parser/ProtoParser.kt)
• ClassTooLong: ProtoReader (wire-runtime-swift/src/main/swift/ProtoCodable/ProtoReader.swift)
• ClassTooLong: SwiftGenerator (wire-swift-generator/src/main/java/com/squareup/wire/swift/SwiftGenerator.kt)
• Coverage not measured — Swift suite
• CycleChecker.packagesCycleMessageError (cognitive 16) (wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/CycleChecker.kt)
• Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
• Documentation: no installation or build instructions
• Documentation: no installation or build instructions (README.md)
• Documentation: no project overview
• Documentation: no usage examples
• Duplicated block (10 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ReverseProtoWriter.kt)
• Duplicated block (10 lines × 2) (wire-schema/src/jsMain/kotlin/com/squareup/wire/schema/Multimap.kt)
• Duplicated block (11 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (11 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/ProtoAdapter.kt)
• Duplicated block (11 lines × 2) (wire-runtime/src/commonMain/kotlin/com/squareup/wire/internal/Internal.kt)
• Duplicated block (11 lines × 2) (wire-schema/src/jsMain/kotlin/com/squareup/wire/schema/Roots.kt)
• Duplicated block (12 lines × 2) (samples/wire-grpc-sample/client/src/main/java/com/squareup/wire/whiteboard/MainActivity.kt)
• Duplicated block (12 lines × 2) (wire-schema/src/commonMain/kotlin/com/squareup/wire/schema/EmittingRules.kt)
• …and 258 more

• 136 commits — 129 feature/other, 7 fixes

• (repo) — 50 commits
• gradle/libs.versions.toml — 27 commits
• wire-gradle-plugin/src — 17 commits
• (root) — 7 commits
• wire-runtime-swift/src — 6 commits
• wire-swift-generator/src — 5 commits
• .github/workflows — 4 commits
• build-support/src — 2 commits
• gradle/wrapper — 2 commits
• samples/js — 2 commits
• wire-golden-files/src — 2 commits
• wire-grpc-client/src — 2 commits
• wire-schema/src — 2 commits
• wire-tests-swift/no-manifest — 2 commits
• samples/android-app-kotlin-minsdk-sample — 1 commit
• wire-compiler/src — 1 commit
• wire-gradle-plugin/build.gradle.kts — 1 commit
• wire-kotlin-generator/src — 1 commit
• wire-schema/api — 1 commit
• wire-tests/jvm-kotlin-proto-reader-32 — 1 commit

• fix: Fix build with Kotlin 2.4.10
• fix: Fix changelog.md
• fix: Fix release workflow
• fix: Merge pull request #3691 from square/fix/kotlin-large-oneof-decode
• fix: Merge pull request #3693 from square/bquenaudon/revert-kotlin-2.4
• fix: Revert Kotlin to 2.3.21 and pin the JVM module name
• fix: Revert kotlinpoet to 2.3.0, the last version built with Kotlin 2.3
• change: Accept AGP Java 17 metadata on the compile classpath
• change: Add wasmWasi target to wire-grpc-client
• change: Assert heap allocation before testing single constant emission
• change: Bump runtime protos
• change: Check in generated Swift for OneOfMessageWithMessages
• change: Declare ProtoIntEncoding Sendable
• change: Decode oneofs in constant size per field in Kotlin
• change: Document the release signing key
• change: Document why storage types skip extension constants
• change: Drop appcompat from the minSdk 21 sample
• change: Drop cross-generator reference from decode comment
• change: Drop support for the deprecated Kotlin/JS plugin
• change: Emit extension field encodings alongside field numbers
• …and 116 more

• Containers 0 added · 0 removed · contexts 15 added · 0 removed · edges 14 added · 0 removed

• jvm-java-kotlin
• server
• wire-compiler
• wire-golden-files
• wire-gradle-plugin
• wire-grpc-client
• wire-grpc-mockwebserver
• wire-gson-support
• wire-gson-support-test
• wire-java-generator
• wire-moshi-adapter-test
• wire-runtime
• wire-schema
• wire-schema-tests
• wire-test-utils

• server → wire-runtime
• wire-compiler → wire-schema
• wire-golden-files → wire-runtime (coupling)
• wire-gradle-plugin → wire-compiler (coupling)
• wire-gradle-plugin → wire-schema (coupling)
• wire-grpc-client → wire-runtime
• wire-grpc-mockwebserver → wire-grpc-client
• wire-grpc-mockwebserver → wire-runtime
• wire-gson-support → wire-runtime
• wire-java-generator → wire-schema (coupling)
• wire-schema → wire-runtime
• wire-schema-tests → wire-schema
• wire-test-utils → wire-runtime
• wire-test-utils → wire-schema-tests

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

square/wire was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.