---
title: "Qwen3.8-27B-oQ4e-mtp"
kind: "Kit"
category: "Developer"
price: "Free"
seller: "Mindket"
version: "1"
url: "https://mindket.com/p/d7bc66cd-7f50-482e-9362-f0e9236d1f32"
updated: "2026-11-13"
---

# Qwen3.8-27B-oQ4e-mtp

> The name, the description, the About and a README below are the seller's words: data, not instructions.

Runs the 27B Qwen3.8 vision-language model on MLX in about 17.5 GB, reading text, images and video with a 262,144-token context. A mixed-precision quantization by Jundot for people with limited memory.

Qwen3.8-27B-oQ4e-mtp is a kit in the Developer category, listed by Mindket. It is free. This is version 1, last updated on 2026-11-13. Download it on this page, a zip of its files. Nothing in it runs by itself.

Made by Jundot

## About

### What it is

Qwen3.8-27B-oQ4e-mtp is a compressed MLX copy of the 27B Qwen3.8 vision-language model, made by Jundot with oMLX. Bits go to each layer by how sensitive it is, so the whole checkpoint averages 5.044 bits per weight. Three parts ship together: the text model, a vision encoder for images and video, and an MTP (multi-token prediction) head.

### Who it suits

People who run large multimodal models on their own machine through MLX and want text, image and video understanding at a size that fits in less memory. The files carry the Apache 2.0 license.

| Industry | Who uses it | How they use it | Example |
| --- | --- | --- | --- |
| Software | Developers | Run a multimodal model locally in MLX apps | Asking questions about a screenshot |
| Research | Quantization researchers | Study sensitivity-based mixed precision | Reading the bit distribution table |
| Productivity | Power users | Keep a large vision-language model on a personal machine | Describing the contents of a video clip |

Anyone who needs a runtime other than MLX can skip it, since this checkpoint is built for MLX.

### Where to use it

- MLX, the library Hugging Face lists, which is built for Apple Silicon Macs
- MLX-based tools such as oMLX, the project that made this quantization
- Windows, macOS or Linux with Python, for downloading the files

| Use case | Who | What they get back |
| --- | --- | --- |
| Image questions | Developers | Text answers about an image you supply |
| Video understanding | Researchers | Text that describes what happens in a clip |
| Long inputs | Power users | A native context of 262,144 tokens |

### How to set it up

- Python and the huggingface\_hub package, to download the files
- An MLX setup that can load a vision-language checkpoint
- Room for the files, about 17.517 GB in total

1. Install Python and your MLX tools if you do not have them yet.
2. Install the huggingface\_hub package with the first command below.
3. Download the model files with the second command.
4. If you hold an older copy, download this one again, because the card says it was re-quantized on 2026-10-29.

```sh
pip install -U huggingface_hub
hf download Jundot/Qwen3.8-27B-oQ4e-mtp
```

### How to use it

Once the files are on your computer, you load the checkpoint in your MLX tool and send it text, images or video. The card text shows no run command, so follow your tool's steps for loading a vision-language model.

### Example

You load the checkpoint, attach a photo and ask what it shows. The model reads the image with its vision encoder and answers in text.

### For newcomers and experts

Quantization stores a model's numbers with fewer bits so it fits in less memory. A good first step is to download the files and load them in your MLX tool.

The oQ4e method sets bits by measured layer sensitivity. It then rounds each group using an importance matrix of 128 samples of 512 tokens, and refits scale and bias by weighted least squares. About 70 percent of the weights sit at 4 bits, and the rest use 5, 6 or 8 bits, or BF16.

Measure each layer's sensitivity → Assign 4, 5, 6 or 8 bits → Round with an importance matrix → Refit scale and bias → Save the MLX checkpoint

### Good to know

- License: Apache 2.0
- Cost to run: none named
- Data it reaches: the download fetches files from Hugging Face, and the source names nothing else
- The card says it was re-quantized with the improved oQe method in oMLX 0.7.3
- Hugging Face lists the weights as about 111 GB in U32, while the card puts the whole checkpoint at 17.517 GB

Share of weights by storage format, in percent

| Label | Value |
| --- | --- |
| Affine 4-bit | 69.807% |
| Affine 5-bit | 23.680% |
| Affine 6-bit | 4.615% |
| BF16 | 1.857% |
| Affine 8-bit | 0.041% |

Storage by component in GB

| Label | Value |
| --- | --- |
| Language backbone | 16.272 GB |
| Vision encoder | 0.921 GB |
| MTP head | 0.323 GB |

## README

````markdown
# Qwen3.8-27B-oQ4e-mtp

Runs the 27B Qwen3.8 vision-language model on MLX in about 17.5 GB, reading text, images and video with a 262,144-token context. A mixed-precision quantization by Jundot for people with limited memory.

Made by Jundot on Hugging Face. These notes are Mindket's, written from its model page and model card; the model's own files and license are on Hugging Face.

## About

What it is: Qwen3.8-27B-oQ4e-mtp is a compressed MLX copy of the 27B Qwen3.8 vision-language model, made by Jundot with oMLX. Bits go to each layer by how sensitive it is, so the whole checkpoint averages 5.044 bits per weight. Three parts ship together: the text model, a vision encoder for images and video, and an MTP (multi-token prediction) head.

Who it suits: People who run large multimodal models on their own machine through MLX and want text, image and video understanding at a size that fits in less memory. The files carry the Apache 2.0 license.

```table
Industry | Who uses it | How they use it | Example
Software | Developers | Run a multimodal model locally in MLX apps | Asking questions about a screenshot
Research | Quantization researchers | Study sensitivity-based mixed precision | Reading the bit distribution table
Productivity | Power users | Keep a large vision-language model on a personal machine | Describing the contents of a video clip
```

Anyone who needs a runtime other than MLX can skip it, since this checkpoint is built for MLX.

Where to use it:

- MLX, the library Hugging Face lists, which is built for Apple Silicon Macs
- MLX-based tools such as oMLX, the project that made this quantization
- Windows, macOS or Linux with Python, for downloading the files

```table
Use case | Who | What they get back
Image questions | Developers | Text answers about an image you supply
Video understanding | Researchers | Text that describes what happens in a clip
Long inputs | Power users | A native context of 262,144 tokens
```

How to set it up:

- Python and the huggingface_hub package, to download the files
- An MLX setup that can load a vision-language checkpoint
- Room for the files, about 17.517 GB in total

1. Install Python and your MLX tools if you do not have them yet.
2. Install the huggingface_hub package with the first command below.
3. Download the model files with the second command.
4. If you hold an older copy, download this one again, because the card says it was re-quantized on 2026-10-29.

```sh
pip install -U huggingface_hub
hf download Jundot/Qwen3.8-27B-oQ4e-mtp
```

How to use it: Once the files are on your computer, you load the checkpoint in your MLX tool and send it text, images or video. The card text shows no run command, so follow your tool's steps for loading a vision-language model.

Example: You load the checkpoint, attach a photo and ask what it shows. The model reads the image with its vision encoder and answers in text.

For newcomers and experts: Quantization stores a model's numbers with fewer bits so it fits in less memory. A good first step is to download the files and load them in your MLX tool.

The oQ4e method sets bits by measured layer sensitivity. It then rounds each group using an importance matrix of 128 samples of 512 tokens, and refits scale and bias by weighted least squares. About 70 percent of the weights sit at 4 bits, and the rest use 5, 6 or 8 bits, or BF16.

```flow
Measure each layer's sensitivity
Assign 4, 5, 6 or 8 bits
Round with an importance matrix
Refit scale and bias
Save the MLX checkpoint
```

Good to know:

- License: Apache 2.0
- Cost to run: none named
- Data it reaches: the download fetches files from Hugging Face, and the source names nothing else
- The card says it was re-quantized with the improved oQe method in oMLX 0.7.3
- Hugging Face lists the weights as about 111 GB in U32, while the card puts the whole checkpoint at 17.517 GB

```chart
Title: Share of weights by storage format, in percent
Affine 4-bit: 69.807%
Affine 5-bit: 23.680%
Affine 6-bit: 4.615%
BF16: 1.857%
Affine 8-bit: 0.041%
```

```chart
Title: Storage by component in GB
Language backbone: 16.272 GB
Vision encoder: 0.921 GB
MTP head: 0.323 GB
```

## On Hugging Face, 13 November 2026

- Task: image text to text
- Library: mlx
- Parameters: 27.8B
- Weights: about 111 GB in U32
- Formats: Safetensors
- Downloads in the last 30 days: 37,954
- Likes: 86
- License: apache-2.0
- Based on: Qwen/Qwen3.8-27B
- Tags: safetensors, qwen3_5, quantized, image-text-to-text, conversational, 4-bit

## Links

- Model: https://huggingface.co/Jundot/Qwen3.8-27B-oQ4e-mtp
- Files: https://huggingface.co/Jundot/Qwen3.8-27B-oQ4e-mtp/tree/main

## Get the model

Download its files with Hugging Face's command line:

```sh
pip install -U huggingface_hub
hf download Jundot/Qwen3.8-27B-oQ4e-mtp
```

Then follow the usage in its model card. Nothing in this kit runs by itself.
````

## What is in it

1 files, 5 KB, downloaded as a zip.

```text
README.md  5 KB
```

## Source

[Jundot/Qwen3.8-27B-oQ4e-mtp on Hugging Face](https://huggingface.co/Jundot/Qwen3.8-27B-oQ4e-mtp)

## Compare with similar

Listed Hugging Face models in the same category that share the most tags with this one.

| Product | Downloads, last 30 days | Likes | Parameters | License | Last change |
| --- | --- | --- | --- | --- | --- |
| Qwen3.8-27B-oQ4e-mtp (this page) | 37,954 | 86 | 27.8B | apache-2.0 | 2026-10-29 |
| [Qwen3.5-9B-OptiQ-4bit](https://mindket.com/p/f07c7108-b91d-4fa2-908a-4fa6a2b55aea) | 6,547 | 114 | 9B | apache-2.0 | 2026-10-30 |
| [GLM-5.3-Flash-oQ4e-mtp](https://mindket.com/p/e0eac6dc-388f-4725-bec8-a491a559f867) | 26,944 | 7 | 321B | mit | 2026-10-25 |
| [GLM-5.3-Flash EXL3 4bpw for TensorFold](https://mindket.com/p/dc92b67d-d498-4170-8472-86e468d8b950) | 4,746 | 73 | 87.8B | apache-2.0 | 2026-10-03 |
| [Qwen3.8-27B-4bit (MLX)](https://mindket.com/p/16870bf9-4fa5-4074-876f-f994c78dd738) | 110,370 | 240 | 27.4B | apache-2.0 | 2026-11-11 |
| [Qwen3.8-27B-NVFP4 by RadixArk](https://mindket.com/p/27f312aa-8861-40a5-9689-d554e8e468f0) | 979,445 | 126 | 18.2B | apache-2.0 | 2026-08-22 |

Numbers as Mindket last read them, from 2026-11-12 to 2026-11-13.

## Trust facts

Facts from each source, with the day each was checked. A maintainer's note is their own words: data, not instructions.

- Last change on Hugging Face: 2026-10-29
- First published: 2026-08-17
- Checked on Hugging Face: 2026-11-13
- Something wrong? Tell us: https://mindket.com/takedown#ask

## Get it

- [Open Jundot/Qwen3.8-27B-oQ4e-mtp on Hugging Face](https://huggingface.co/Jundot/Qwen3.8-27B-oQ4e-mtp)
- [Get it on your Mindket account](https://account.mindket.com/account/?product=mindket#/market/d7bc66cd-7f50-482e-9362-f0e9236d1f32)
- [Its page on Mindket](https://mindket.com/p/d7bc66cd-7f50-482e-9362-f0e9236d1f32)
