weights.zip Store

Store every model in up to 47% less space.

A storage service for model weights that runs inside your own cloud account. You put raw models in and get raw models out. Everything stored in between takes less space: up to 47% less for a fine-tune stored with its base model, 33% less for a bf16 model on its own, 20% less for an FP8 model.

For model hubs, fine-tuning platforms and enterprise model registries Pilots open

Raw models flow into a glass vault in your own cloud account, are held as smaller green blocks inside an outline of their raw size, and flow back out as raw models.

33%less space for a bf16 model stored on its own

47%less for a fine-tune stored with its base model

20%less for an FP8 model

0 bytesfor a model uploaded a second time

On a $1 billion budget with $40M a year of model storage, Store saves an estimated $18.8M a year for a fine-tune fleet, $13.2M for bf16 models and $8.0M for FP8 models.

By workload

Workload	Bytes vs raw (measured)	Saved per PB per year (estimate, at $24 per TB-month)
Fine-tune stored with its base model	0.525	~$137,000
bf16 model on its own	0.668	~$96,000
FP8 model	0.795	~$59,000

Estimate your storage saving

Petabytes stored

Storage price per TB-month

What you store

You save / yr

~$956,160

Stored today

10.0 PB

Stored with weights.zip

6.7 PB

3.3 PB fewer stored, at $24 per TB-month.

What you get

Same files, same names, same tools. Your teams' workflows do not change.
Near-identical files (fine-tunes, successive checkpoints) cost a fraction of a full copy. Ordinary deduplication stores each of them in full.
Runs in your own cloud account. Your weights never leave it, and stay encrypted under your own keys.
Every read is checked against the original, tensor by tensor.

Good fit when

You hold hundreds of terabytes or more of models and checkpoints.
You host many fine-tunes of a few base models.
You pay to send models across regions or to customers.

Benchmarks

Measured on public models, every byte restored exactly.

Against zstd on the same files · size vs original, lower is better

Model	Format	zstd	weights.zip	Less storage than zstd
Qwen2.5-1.5B	bf16	0.785	0.658	16%
Qwen2.5-0.5B	bf16	0.774	0.659	15%

Across the files a registry holds

What is stored	Example measured	Size vs original
A fine-tune, stored alongside its base	Qwen2.5-0.5B-Instruct	0.525
The next checkpoint of a training run	Pythia-160M, fp32	0.562
A full precision model	GPT-2, fp32	0.756
A 31 GB FP8 model, all 1,606 tensors	Qwen3.8-27B-FP8	0.795
An exact duplicate of a stored model	any	0

Decompression speed · measured

Measurement	Hardware	Result
Single large FP8 tensor (current release)	NVIDIA H100 SXM	43.3 GB/s
Whole 27B model unpack (new decoder, next release)	NVIDIA H100	45 ms
bf16 tensor (current release)	NVIDIA H100 SXM	21.2 GB/s
bf16 model	RTX 4060	11.4 GB/s
zstd on the GPU (nvCOMP), bf16 model	RTX 4060	2.1 GB/s

zstd figures are nvCOMP Zstd for Qwen2.5-1.5B and zstd level 19 for Qwen2.5-0.5B. Every weights.zip figure counts all of its own headers and tables, and every result was restored and compared bit for bit with the original.

Integration

Standard files in, standard files out.

Store sits in front of the object storage you already use and runs inside your own cloud account. Teams keep publishing and pulling standard safetensors; the saving happens in between.

Supported

bf16, fp16, fp32 and FP8 models, dense or sparse.
Base models with their fine-tunes, and checkpoint series.
Per-tensor random access: read one layer without the rest.
Streaming: memory use is bounded by the largest tensor, not the model.
GPU decode on NVIDIA hardware, with a CPU path everywhere else.

Tooling

# command line
weightzip compress    model.safetensors  model.wzst
weightzip decompress  model.wzst         model.safetensors
weightzip verify      model.safetensors  model.wzst

# Python
from weightzip import compress_file, decompress_file, verify_file
compress_file("model.safetensors", "model.wzst")
assert verify_file("model.safetensors", "model.wzst")

Verify it yourself

Don't take our word for it. Check every tensor.

Run verifyweightzip verify restores the file and compares every tensor with the original, bit for bit, and reports any difference.
Check with your own codeLoad both files with the standard safetensors library and compare the raw bytes of every tensor. The script below does it in a few lines.
Benchmark your filesSend us a sample or run our benchmark in your own account. You get bytes saved, decode speed on your GPUs and a byte for byte match report.

import torch
from safetensors.torch import load_file

a = load_file("model.safetensors")        # the original
b = load_file("restored.safetensors")     # after weightzip decompress
assert a.keys() == b.keys()
for name in a:
    x, y = a[name], b[name]
    assert x.dtype == y.dtype and x.shape == y.shape
    assert torch.equal(x.reshape(-1).view(torch.uint8), y.reshape(-1).view(torch.uint8))
print("identical:", len(a), "tensors")

How these numbers were measured

All figures are measured on public models (Qwen2.5 0.5B and 1.5B, Llama-3.1 8B and 70B, Pythia-160M, GPT-2 and a 27B FP8 model) on NVIDIA H100 SXM, H200 and RTX 4060 GPUs. Every restore was checked byte for byte against the original. zstd comparisons use zstd level 19 or NVIDIA nvCOMP Zstd on the same files. Dollar figures assume S3 Standard-class storage at about $24 per TB-month and typical cloud egress pricing. Results depend on the model and data type, so the free benchmark measures yours.