embeddinggemma-300m-CoreML

embeddinggemma-300m — Core ML (int8, seq 128, ANE)

google/embeddinggemma-300m as a compiled Core ML encoder for Apple silicon, mirrored and rebuild-verified by visible-cx. One call in, one 768-d L2-normalised embedding out.

This is the one artifact in this org whose weights reproduce bit-exactly from the published recipe. An independent rebuild on a different operating system and CPU architecture produced a weight.bin identical to the published one — SHA-256 f81f60eb…, 0 of 308,616,576 bytes differing. Every Core AI .aimodel bundle in this org has to rest on digests instead, because that exporter is not deterministic even against itself.

This is Core ML, not Core AI. It is an .mlmodelc loaded through MLModel, and the CoreAIKitEmbeddings.TextEmbedder used by the sibling visible-cx/embeddinggemma-300m-CoreAI repo will not load it — that type looks for a *.aimodel in the bundle directory. Pooling, the dense stack and L2 normalisation are inside this graph, so there is no host-side pooling to implement either way.

Contents

3fa12f0b97b8afe23264f76800afe14af4615ca5/ — the pinned upstream artifact, byte for byte, under its upstream revision as the directory name. 309,358,096 B total.

rebuild-verification/2026-08-17/ — an independent rebuild of the same recipe on a different operating system and CPU architecture, published so the reproducibility claim can be checked rather than taken on faith. 309,346,242 B total.

The shapes differ deliberately: the pinned artifact is a compiled .mlmodelc, the rebuild is the uncompiled .mlpackage the recipe emits. Compilation (xcrun coremlcompiler) is a macOS-only step and was not performed on the rebuild host.

Provenance

The mirror was verified byte-exact against upstream on all six files of the published artifact.

Requirements

• Apple silicon, Core ML runtime. The encoder is shaped for the Neural Engine.
• Static sequence length 128. Inputs must be padded or truncated to 128 tokens; this is a compile-time property of the artifact, not a runtime option.
• Weights ≈ 0.31 GB resident. No KV cache — this is an encoder, so there is no per-token memory growth and no context ladder. Minimum practical machine memory: 8 GB.
• model_config.json beside the encoder carries the pooling / dense / normalisation contract the host must honour.

Note the sequence-length difference from the Core AI artifact in this org, which is seq 256. The two are not drop-in substitutes for each other, and vectors from one should not be compared against vectors from the other.

Measurements

No throughput or latency figure is published here, and none has been taken. The ANE residency figure above is upstream's published claim, not a measurement made here.

One cross-runtime quality datapoint is on record: a cosine of ~0.966 on short text between this Core ML encoder and the LiteRT .tflite of the same base model — measured against previously installed copies rather than against the files in this repo, so read it as an indication that the two runtimes agree closely on short text, not as a parity gate on these bytes.

Verification

Weights and config reproduce bit-exactly from the recipe, across operating systems and CPU architectures:

So the claim is scoped precisely: everything the recipe produces reproduces exactly; the remaining four files are a macOS compile step that was not run. Closing that gap means compiling rebuild-verification/2026-08-17/encoder.mlpackage on a Mac and diffing the resulting encoder.mlmodelc against the pinned artifact. SHA256SUMS and VERIFICATION.md in that folder carry the rebuild's own receipts.

Usage

Core ML, no third-party package required. Load the compiled .mlmodelc directly and honour the contract in model_config.json:

import CoreML

let url = /* …/3fa12f0b97b8afe23264f76800afe14af4615ca5/encoder.mlmodelc */
let config = MLModelConfiguration()
config.computeUnits = .cpuAndNeuralEngine   // the encoder is shaped for the ANE

let encoder = try MLModel(contentsOf: url, configuration: config)
// inputs: token ids + attention mask, padded/truncated to 128
// output: a 768-d L2-normalised embedding — cosine == dot product

Pooling, the dense stack and normalisation are already in the graph, so the output is directly comparable; do not re-normalise or re-pool.

Two things to hold onto:

• Pad or truncate to exactly 128 tokens. The length is compiled in.
• Apply EmbeddingGemma's query and document prompt prefixes yourself. Unlike the Core AI sibling — where TextEmbedder supplies them — nothing here does it for you, and embedding a query with the document prefix quietly degrades retrieval.

Status

License

EmbeddingGemma is Gemma-family and the upstream checkpoint is gated on Hugging Face. These files are a derivative of google/embeddinggemma-300m and use is subject to the Gemma Terms of Use and the Gemma Prohibited Use Policy. Those terms travel with the artifact and with any redistribution of it. The contribution here is the mirror and the rebuild verification, not the weights.