Julia 2
A 1.06-billion-parameter decision model for text, images, recorded speech, and live audio. It reads the shared context once and answers several questions about it.
Download Julia 2 on Hugging Face

How it works
Send the context, your questions, and the choices or scoring criteria. Julia 2 returns structured probabilities for choice, score and yes/no (noul), using the request and response format of Julia 1.5. The runtime accepts up to 255 options per choice, with a two-round method for larger lists.
The network uses 18 linear-attention layers and six full-attention layers. Each question branches from the same state. Text and JSON can be combined with images or recorded speech through the model’s own encoders. When the input grows, the live runtime can append new audio or text and update the answers without processing the earlier input again.
For example, pass an inspection photo and a part number to ask both whether the part is visibly damaged and which defect it shows. For live calls, open a session with fixed questions, push audio chunks as they arrive, and read updated routing or urgency decisions. Python and multimodal examples
Results
These are early internal evaluations. For the text and audio results below, the reference checkpoint is BF16. The accuracy and consistency numbers describe the named tests. Evaluation data
| Evaluation | Result |
|---|---|
| SLCMB 3.0, full set | 64.7 points |
| SLCMB 3.0, development split | 67.7 points |
| Held-out business decisions, 6,000 questions across four workflows | 77.2% accuracy |
| Expected calibration error on that business test | 0.033 |
| Same answer with reordered options | 95.8% |
| Spoken facts, 268 questions | 93.7% |
| Recorded intents, MInDS-14, 2,413 utterances | 75.3% |
| Final accuracy across six questions on 115 held-out calls | 75.8% |
In the held-out calls, an experimental alert flagged 94% of scam calls before the call ended and raised false alarms on 32% of legitimate calls. Use those alerts for review. On tests where one buried fact determined the answer, accuracy fell from 63% at 2K tokens to 53% at 32K. The model card also reports weaker performance on fast speech and Portuguese recordings in its audio tests. Model card and limits
| BF16 on NVIDIA RTX PRO 6000 | Median latency |
|---|---|
| One text question | 4.7 ms |
| Six text questions on the same context | 11.7 ms |
| One question on a 1.6 MP image | 61.6 ms |
| One question on 10 seconds of speech | 49.6 ms |
| Append a 0.96-second audio chunk during a call | 41.8 ms |
Run locally
Use Python 3.10+ and the supplied PyTorch runtime. CUDA is recommended for higher loads. The CPU path works for smaller workloads. Use the runtime’s optional audio dependencies for audio files. Weights and runtime are Apache 2.0, with notices for third-party components. Runtime and notices
python -m pip install huggingface_hub
hf download SupersonicLabs/Julia-2 --local-dir Julia-2 --exclude "int4/*" "int8/*"
python -m pip install -e ./Julia-2/runtime
from julia2 import Runtime
model = Runtime("Julia-2")
result = model.predict_questions(
state={"ticket": "I was charged twice for the same order."},
questions={
"team": {
"type": "choice",
"instructions": "Which team should handle the ticket?",
"criteria": {"billing": "Charges and refunds", "technical": "App errors"},
},
"priority": {
"type": "score",
"instructions": "Support priority",
"criteria": ["low", "medium", "high"],
},
},
)
print(result["answers"])
| Precision | Weights | Peak GPU memory in the model manifest | Answer agreement with BF16, text / speech / live |
|---|---|---|---|
| BF16 | 2.14 GB | 3.74 GB | Reference |
| INT8 | 1.39 GB | 2.94 GB | 99.3% / 99.4% / 99.4% |
| INT4 | 1.16 GB | 2.71 GB | 99.7% / 95.8% / 98.7% |
For a smaller checkpoint, include the corresponding folder in your download and set precision="int8" or precision="int4" when constructing the runtime. Test quality on your inputs, particularly for speech and long contexts. Model manifest
Flash and Nano
Julia 2 Flash

Flash keeps the Julia 2 API and supports the same input types. The full model uses 658 MB of weights, including 427 MB for text, 116 MB for images and 115 MB for audio. Load just text with Runtime("Julia-2-Flash", modalities=("text",)).
In the card’s paired evaluation on 222 held-out SLCMB items, Flash scored 0.07 points below Julia 2 BF16. In its RTX PRO 6000 test, peak GPU memory fell from 3.74 GB to 1.08 GB and a batch of 64 text questions went from 295 ms to 171 ms. Some answers change, with larger differences on a few languages and fine-grained image classes. Julia 2 Flash weights, runtime and evaluations
hf download SupersonicLabs/Julia-2-Flash --local-dir Julia-2-Flash
Use the included Julia-2-Flash/runtime with Python and PyTorch. For text-only deployment, the model card identifies which files you need to keep. Flash setup and file layout
Julia 2 Nano

Nano uses 15 MB of weights in three files and runs in C. The repository includes firmware targeting the ESP32-S3 for text decisions. The image and speech programs use fixed label sets, and the card does not report measured latency on a real board.
| Component | Weights | Scope |
|---|---|---|
| Text | 8.2 MB | Choice, score and yes/no decisions in English and Portuguese |
| Images | 1.7 MB | Trained Imagenette and Oxford Flowers classes |
| Speech | 5.1 MB | 14 banking intents from MInDS-14 |
Nano matched Julia 2 on 58% of 231 held-out SLCMB text cases, reaching 71% on the 166 cases where Julia 2 was confident. These are answer-agreement rates. Nano targets short inputs and fixed decisions. For live calls or long contexts, use Julia 2 or Flash. Julia 2 Nano weights, C examples and firmware
To compile the text program on a computer with a C compiler:
hf download SupersonicLabs/Julia-2-Nano --local-dir Julia-2-Nano
cd Julia-2-Nano
cc -O2 -o nano_text c/nano_text.c -lm
The program reads a packed input file and the text weights. Use the file format guide to prepare inputs or the ESP-IDF project in firmware/ to build for ESP32-S3. Nano input formats