mashbox 0.1.12

MASHBOX Labs makes open models run faster and cheaper on TPUs and accelerated hardware, as well as exploring the future of the intersection of AI and gaming.

Install • Models • Docs • Hugging Face • Coding agents

Qwen3.8-27B on one TPU v6e chip: first-time install to first answer (sped up 10x).

Install

Two lines on your own machine (Linux or macOS, x86_64 or arm64; on Windows, use WSL2). The first installs the mashbox command, the second gets a Google Cloud TPU chip and starts Qwen3.8-27B on it:

curl -fsSL https://mashbox.gg/install.sh | sh
mashbox tpu up qwen3-8-27b

Line 2 needs the Google Cloud CLI, signed in to a project with billing and the TPU API turned on; Run on Google Cloud TPU steps 1 to 5 do that from a new Google account. It prints the chip's price per hour and asks before it creates anything. Then it installs the same mashbox version on the chip and starts the server there, reached through an SSH tunnel from your machine. mashbox tpu down mashbox-qwen3-8-27b deletes the chip, and if you forget, the chip deletes itself at its max lifetime.

On a machine that has a TPU, such as a Cloud TPU VM you created yourself, the same line 1 installs the TPU version and mashbox run runs a model there:

curl -fsSL https://mashbox.gg/install.sh | sh
mashbox run qwen3-8-27b --prompt "Write a haiku about the sea."

If the shell does not find mashbox after line 1, ~/.local/bin is not on your PATH: line 1 printed the export PATH=... line for this terminal, or call it as ~/.local/bin/mashbox. To do the same by hand with gcloud, one chip and one answer: Quickstart.

What each install adds:

Each one needs Python 3.12 or newer. Line 1 installs with uv, which brings its own Python 3.12, since a Cloud TPU VM's system Python is 3.10. On a TPU VM without line 1: python3 -m pip install uv && python3 -m uv tool install --python 3.12 "mashbox[tpu]". For Hy-Nomas with line 1, name the extras:

curl -fsSL https://mashbox.gg/install.sh | MASHBOX_EXTRAS=tpu,hy-nomas sh

mashbox run fetches the compiled TPU kernels a model uses by itself, so there is nothing to install or pick. They come from two places. The engine kernel package, used for GGUF files and Hugging Face models, is one file attached to a mashbox release on GitHub; models.json lists it under engine_kernels, with the chips and the JAX version it is built for. Each MASHBOX build that ships kernels has its own kernel package in its Hugging Face repo, under kernels/. mashbox run checks every file against its sha256 in models.json before it uses it. When no package fits the chip and the JAX version, the model runs without one, on plain JAX, which is slower, and the log says so.

The chip bills from create to delete: one TPU v6e chip is $2.70 an hour at Google's on-demand list price. Qwen3.8-27B's options, chips and results: docs/models/qwen3-8-27b.md.

Models

37 models and files run in mashbox: 4 MASHBOX builds and 33 GGUF files of 20 models.

MASHBOX builds

Models we port or make ourselves. A BSHJ build is our weights file for the model, run on our TPU kernels. Measured is each one's number against its baseline, on the chip named.

GGUF files that run in our engine

GGUF files from other publishers, run as they are by mashbox. Level and Runs on say how far each file has been checked; a speed shows only where a chip run measured it on our kernels.

Full catalog, with the run command for each file.

Listed, not in mashbox run

Models we publish that mashbox run does not start in this version. Each names the device its files are made for and links the page that shows how to use them.

Every number names the chip it was measured on; each model's guide has all its results. Options for any model: ~/.local/bin/mashbox run <model> --help.

Results

Each chart names the hardware on both sides.

_{Qwen3-30B-A3B is not in this package: this chart compares quantized files of it, each scored the same way.}

What you get

• One command per model. mashbox run <model> downloads the weights, checks every file's sha256, loads the model and serves it.
• Fits on fewer chips. Qwen3.8-27B runs on a single TPU v6e chip (32 GB) from a 26.94 GB weights file at 8.01 bits per weight, with 99.72% top-1 agreement against Qwen's own bf16 weights.
• Fast starts. Models ship their compiled TPU kernels, and Qwen3.8-27B also ships a precompiled compile cache for TPU v6e, so a start skips compiling: Qwen3.8-27B on TPU v6e-1 is ready in 69.6 s with it, 326.6 s without it.
• An OpenAI-compatible server for the language models, with batching: 8 requests at once share the chip.
• Works with Claude Code, Codex and Pi. The server also speaks the Anthropic Messages and OpenAI Responses APIs, so coding agents can use a model you serve as their LLM: Use with coding agents.
• Docs for coding agents. AGENTS.md gives an agent the rules and the steps to set up a chip, run a model and delete the chip; llms.txt lists the docs.
• Named files. Every weights file on Hugging Face is named by its type (for example Qwen3.8-27B-BQ8_R.bshj), with size, bits per weight and measured quality next to it.

TPU v6e and v5e

v6e is the default. A model too big for one v5e chip (16 GB) splits across the 4 chips of a v5e-4 when its row says so; the models table says which chips each model runs on. Specs from Google's v6e and v5e pages. More in docs/chips.md.

TPU v6e (one chip and a v6e-4) against one NVIDIA H100 at Google Cloud list prices, with the memory bandwidth of each and the cost per 1M output tokens of Qwen3.8-27B (27B parameters, dense): TPU or GPU: price and bandwidth.

Open code, compiled kernels

The source of the model ports, CLI, runtime, demo apps and docs is in this repo, under Apache-2.0. The TPU kernels (our Culet kernels) ship compiled, as files that mashbox run fetches and checks by itself, with a precompiled compile cache where we built one; Install says where each kernel package comes from. Models that list plain JAX as tested also run without them, slower. The compiled files are under the MASHBOX Kernel Licence: free for personal use, research and evaluation, and for any use by companies under US$1M annual revenue. Larger companies in production: hello@mashbox.gg.

Coding agents

Use a model as your agent's LLM. Claude Code, Codex and Pi work with every LLM that mashbox run serves: start the server, open the tunnel, set the agent's base URL. Settings for each agent and measured results: Use with coding agents.

Let an agent set it up. AGENTS.md gives an agent the rules and the steps, from a Google account to a run and a deleted chip, and tells it to ask you before anything that costs money. llms.txt lists the docs.

Community and links

Licence

Our code is under the Apache License 2.0. The compiled kernels and compile cache are under the MASHBOX Kernel Licence. Model weights keep each model's own licence, shown on its Hugging Face card and kept unchanged in licenses/. Details: docs/licence.md.

Citation

@software{mashbox,
  author = {{MASHBOX Labs}},
  title = {mashbox: open models that run faster and cheaper},
  url = {https://github.com/mashbox-labs/mashbox},
  year = {2026}
}

Thank you

• Tencent Hunyuan for Hy-Nomas and Qwen for Qwen3.8-27B, and for releasing their weights.
• The JAX and Pallas teams, and Google Cloud TPU.
• llama.cpp and the ggml authors for GGUF; mashbox reads GGUF files with their gguf package (GGUF files).
• Hugging Face for hosting the weights and uv for a one-line Python 3.12.