Experimental multilingual fine-tune of Julia-1 for fast bounded-decision routing on AMD Strix Halo-class local machines. This is an experimental v0.2 multilingual candidate, not a replacement for the English-focused v0.1 checkpoint. - task routing over fixed options - documentation-update triage - context-management metadata - non-authoritative tool-policy hints Do not use this model as the final authority for destructive commands, credential handling, production deploys, security replay safety, durable memory writes, summarization, or final prose. By language on the large multilingual holdout: All latency numbers in development were measured on CPU. NPU acceleration has not been validated.…
Julia-1-MLX is an open-weight model for text classification from Zain Merchant, released under Apache License 2.0. It has 144M parameters. At 16-bit it needs about 0.3 GB of GPU memory, which fits on 1x MI300X from $1.85 an hour, at the lowest prices in the SAVRN Index.
Julia-1 for Apple silicon. Runs Supersonic Labs' Julia-1 decision model on the Mac's GPU with MLX through the julia-mlx runtime: the same answers as the official PyTorch runtime on its published evaluations, 5–14× faster on the same Mac.
Parameters144M
Context—
Weights577.2 MB
Licenseapache-2.0
AccessOpen weights
Monthly Downloads—
Runs On
What it takes to serve Julia-1-MLX (144M parameters): the memory its weights need at each precision, and the cheapest way to rent enough data-center GPUs to hold them.
| Precision | Weights | Memory needed | Cheapest setup | Per hour | Also fits |
|---|---|---|---|---|---|
| 16-bit | 0.3 GB | 0.3 GB | 1x MI300X (192 GB) Vultr |
$1.85 | 1x H100 $1.99 · 1x MI325X $2.00 |
| 8-bit | 0.1 GB | 0.2 GB | 1x MI300X (192 GB) Vultr |
$1.85 | 1x H100 $1.99 · 1x MI325X $2.00 |
| 4-bit | 0.1 GB | 0.1 GB | 1x MI300X (192 GB) Vultr |
$1.85 | 1x H100 $1.99 · 1x MI325X $2.00 |
Memory is the weights at that precision plus 20% for the runtime and a short context; a long context needs more. Prices are the lowest on-demand hourly rates in the SAVRN Index, read Oct 1, 2026.
Julia-1-MLX on every accelerator the SAVRN Index prices, at every precision
Model Card
By Zain Merchant, published under apache-2.0, revision 0187087786ee.
Julia-1 for Apple silicon. Runs Supersonic Labs' Julia-1 decision model on the Mac's GPU with MLX through the julia-mlx runtime: the same answers as the official PyTorch runtime on its published evaluations, 5–14× faster on the same Mac. The upstream model repository is SupersonicLabs/Julia-1. The files in this repository are Supersonic Labs' Julia-1 checkpoint, unchanged (model.safetensors SHA-256 df853bf7fe424420011f3d0c47a05d7341aa9eefa7fb9f203ea4aada4ad95b72). The runtime maps it into MLX directly, so no converted copy is needed. Precision (dtype="float16") and embedding placement are load-time options rather than separate files. This is an independent project, not affiliated with or…
Read Zain Merchant's full model card
Julia-1 for Apple silicon. Runs Supersonic Labs' Julia-1 decision model on the Mac's GPU with MLX through the julia-mlx runtime: the same answers as the official PyTorch runtime on its published evaluations, 5–14× faster on the same Mac. The upstream model repository is SupersonicLabs/Julia-1.
The files in this repository are Supersonic Labs' Julia-1 checkpoint, unchanged (model.safetensors SHA-256 df853bf7fe424420011f3d0c47a05d7341aa9eefa7fb9f203ea4aada4ad95b72). The runtime maps it into MLX directly, so no converted copy is needed. Precision (dtype="float16") and embedding placement are load-time options rather than separate files.
This is an independent project, not affiliated with or endorsed by Supersonic Labs.
Usage
pip install julia-mlx
from julia_mlx import load_model
engine = load_model("zainmerchan/Julia-1-MLX", max_length=1024, head_length=512, strict_encoding=True)
result = engine.predict(
state="I was charged twice for the same order.",
questions={
"team": {
"type": "choice",
"instructions": "Which team should handle this request?",
"criteria": {"billing": "Billing and payment disputes", "shipping": "Shipping and delivery", "access": "Account access and login"},
},
},
)
print(result["answers"]["team"]["choice"])
load_model("SupersonicLabs/Julia-1") loads the upstream repository the same way.
Accuracy
Supersonic's published CPU evaluation, rerun on the same pinned data and settings. FP32 is the default.
| Evaluation | Published (PyTorch CPU) | MLX FP32 | Same winner as PyTorch |
|---|---|---|---|
| typed-decisions (choice / noul / score) | 1,451 / 2,000 (426 / 483 / 542) | 1,451 (426 / 483 / 542) | 2,000 / 2,000 |
| AG News pilot, 4 labels | 94 / 100 | 94 | 100 / 100 |
| DAIR Emotion pilot, 6 labels | 86 / 100 | 86 | 100 / 100 |
| Banking77 pilot, 72 labels | 60 / 100 via an unpublished shortlist | 62 via Router (PyTorch: 62) |
100 / 100 |
The largest FP32 logit difference from PyTorch is 0.00115. See the runtime README for FP16 results and the evaluation protocol.
Performance
On an Apple M4 Pro, against the reference PyTorch runtime on the same machine's CPU:
| Workload | PyTorch CPU | MLX FP32 | MLX FP16 |
|---|---|---|---|
| Single call, median | 34.15 ms | 6.62 ms | 6.41 ms |
| 2,000 typed questions, batch 16 | 24.46 /s | 143.37 /s | 169.02 /s |
| 16 requests × 8,192 tokens | 83.41 s | 5.91 s | 4.97 s |
Attribution
- Julia-1 (weights, decision head, typed API) by Supersonic Labs, Apache-2.0: SupersonicLabs/Julia-1.
- mmBERT-small by Johns Hopkins CLSP (jhu-clsp/mmBERT-small), the encoder and tokenizer Julia-1 builds on.
- ModernBERT by Answer.AI and LightOn, the encoder architecture.
- The MLX encoder derives from pappitti/modernbert-mlx (MIT).
The weights keep their Apache-2.0 license. The julia-mlx runtime is MIT-licensed.
Identity and Version
- Repository
- zainmerchan/Julia-1-MLX
- Publisher
- Zain Merchant
- Task
- Text classification
- Modality
- Text
- Library
- mlx
- Parameters
- 144M parameters
- Languages
- mlx
- Revision
- 0187087786ee6428fd4a92e454024058b1a46221
- First published
- 2026-09-27
- Last updated
- 2026-09-27
Files and Weights
8 files, 611.6 MB in total. The weights are 1 file totalling 577.2 MB in safetensors.
Weights1 file · 577.2 MB
Configuration2 files · 2.1 KB
Tokenizer2 files · 34.4 MB
Documentation2 files · 15.1 KB
Repository1 file · 1.6 KB
Every file
| File | Type | Size | SHA-256 |
|---|---|---|---|
| model.safetensors | Weights | 577.2 MB | df853bf7fe42 |
| encoder/config.json | Configuration | 1.9 KB | — |
| julia_config.json | Configuration | 147 B | — |
| LICENSE | Documentation | 11.4 KB | — |
| README.md | Documentation | 3.7 KB | — |
| .gitattributes | Repository | 1.6 KB | — |
| tokenizer/tokenizer.json | Tokenizer | 34.4 MB | 609d8f4c067c |
| tokenizer/tokenizer_config.json | Tokenizer | 652 B | — |
License and Download
- License
- apache-2.0
- Access
- Open weights, no gate
- Download size
- 577.2 MB
Download from Zain Merchant
Released by Zain Merchant through its official repository on Hugging Face. Read the license.
Built From
- Derived from SupersonicLabs/Julia-1
- Quantized from SupersonicLabs/Julia-1
Memory Requirements
| Precision | Weights in memory |
|---|---|
| As published | 577.2 MB |
| 16-bit | 0.3 GB |
| 8-bit | 0.1 GB |
| 4-bit | 0.1 GB |
Weights only, from the published parameter count; the key-value cache and runtime add to this.
Questions About Julia-1-MLX
How much GPU memory does Julia-1-MLX need?
About 0.3 GB at 16-bit and 0.1 GB at 4-bit: the weights (144M parameters) plus a working margin. A long context needs more.
What is the cheapest GPU to run Julia-1-MLX on?
At 16-bit, 1x MI300X from $1.85 an hour; at 4-bit, 1x MI300X from $1.85 an hour, at the lowest on-demand prices the SAVRN Index lists.
Can I use Julia-1-MLX commercially?
Yes. Julia-1-MLX is released under Apache License 2.0. The Apache License 2.0 is a permissive open-source license. It permits commercial use, modification and redistribution. It requires keeping the license and copyright notices and any NOTICE file, stating significant changes, and it includes an express patent grant from contributors.
Similar Models
A fast, multilingual classifier that flags prompt injection and jailbreak attempts, both in user messages (direct) and in untrusted content an AI agent reads: emails, web pages, documents, RAG chunks, and tool/API outputs (indirect). their clean counterparts, so it looks for instructions aimed at the AI, not for scary words. - Low false-alarm rate on look-alike benign text: 89.7% on NotInject, 99.5% on OR-Bench-hard. half the size and the same decisions as fp32 on our checks), transformers.js. Labels: SAFE (0) and INJECTION (1). This is the same convention as protectai/deberta-v3-base-prompt-injection-v2, so the model is a drop-in replacement in code and tools built for that one. INJECTION…
Hierarchical document classifier for the LLM-Mailroom intake pipeline: a fine-tuned ModernBERT-base encoder with a doctype head plus one subclass head per document class. It is the deterministic pre-check in the BERT-coupled intake overhaul (mailroom-issues #85). 8,192-token context, bf16. heads (contract, corporaterecord, correspondence, insuranceclaim, mergeragreement). MLP heads with dropout 0.1. by plurality vote over windows; subclass by plurality over windows whose doctype vote is the winning class. doctype (6): contract, mergeragreement, corporaterecord, correspondence, insuranceclaim, unknown (inference-only abstention — not a trained class) development, distributor, endorsement…
Firebird-ModernBERT-512-RW is an experimental post-trained variant of It is a ~149M parameter ModernBERT binary classifier for distinguishing: - 0 — HUMAN The maximum sequence length is 512 tokens. This checkpoint was produced through reward-weighted classifier post-training. The original Firebird checkpoint was kept frozen as a reference model. Training examples were scored by the original classifier, difficult examples received larger loss weights, and the post-trained model was constrained against the frozen reference using a KL penalty. L = weightedcrossentropy + beta KL(reference || policy) Hard human examples received greater weighting than ordinary examples because one goal of the…
Pyrrho is a CPU-runnable co-processor for retrieval-augmented generation. It reads a question before retrieval to suggest what evidence to seek, then reads the question with retrieved passages to assess whether those passages support an answer. A surrounding RAG runtime decides whether to answer, retrieve again, or surface a conflict. The broader project is described in the The evidence verdict is SUFFICIENT, DISPUTED, or INSUFFICIENT. These are predictions about the supplied passages. The model does not retrieve sources, generate answers or citations, check external facts, or prove that a corpus has been searched completely. The two passes use the same encoder with different input…
This model is distilled from the zero-shot classification pipeline on the Multilingual Sentiment dataset using this script. In reality the multilingual-sentiment dataset is annotated of course, but we'll pretend and ignore the annotations for the sake of example. Result can be reproduce using the following commands: If you are training this model on Colab, make the following code changes to avoid Out-of-memory error message: - Transformers 4.28.1 - Pytorch 2.0.0+cu118 - Datasets 2.11.0 - Tokenizers 0.13.3