Instructions to use maylore-ai/Temper-2-Nodel with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use maylore-ai/Temper-2-Nodel with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("text-generation", model="maylore-ai/Temper-2-Nodel")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# pip install -U transformers accelerate
# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("maylore-ai/Temper-2-Nodel")
model = AutoModelForCausalLM.from_pretrained("maylore-ai/Temper-2-Nodel", device_map="auto")
messages = [
    {"role": "user", "content": "Who are you?"},
]
inputs = tokenizer.apply_chat_template(
	messages,
	add_generation_prompt=True,
	tokenize=True,
	return_dict=True,
	return_tensors="pt",
).to(model.device)

outputs = model.generate(**inputs, max_new_tokens=256)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use maylore-ai/Temper-2-Nodel with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "maylore-ai/Temper-2-Nodel"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "maylore-ai/Temper-2-Nodel",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker

docker model run hf.co/maylore-ai/Temper-2-Nodel

SGLang

How to use maylore-ai/Temper-2-Nodel with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "maylore-ai/Temper-2-Nodel" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "maylore-ai/Temper-2-Nodel",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "maylore-ai/Temper-2-Nodel" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "maylore-ai/Temper-2-Nodel",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use maylore-ai/Temper-2-Nodel with Docker Model Runner:
```
docker model run hf.co/maylore-ai/Temper-2-Nodel
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Temper-2-Nodel

Temper 2 Nodel is the largest model of the Temper 2 line and the first built on Qwen3.5. It is meant for applied Rust tasks with traits, generics and threads, which the smaller Temper-2-Ion and Temper-2-Axon solve much less often, and it solves them better than any model up to 9B parameters we tested. Like them, it understands requests in Russian and English, including short casual ones.

Website: maylore.com/temper-2-nodel

Results

HumanEval-RS and MBPP-RS show pass@1 / pass@10, %. pass@1 is the percentage of tasks solved on the first attempt, pass@10 the percentage solved in at least one of 10 attempts.

model	HumanEval-RS	MBPP-RS	Temper Bench v2 (greedy pass@1)
Qwen3.6-35B-A3B	89.2 / 95.3	78.1 / 83.3	63.3
Gemma 4 26B-A4B	86.8 / 90.6	75.0 / 78.3	74.7
Qwen3.5-9B	76.0 / 90.2	65.6 / 79.2	29.3
Temper-2-Nodel	73.2 / 82.6	64.8 / 71.1	37.3
Qwen2.5-Coder-7B-Instruct	72.4 / 82.6	60.5 / 70.0	26.0
Tessa-Rust-T1-7B	71.5 / 79.0	57.8 / 68.9	29.3
Qwen3.5-4B	66.2 / 81.4	57.7 / 73.4	20.7
Temper-2-Axon	64.2 / 73.8	54.7 / 61.7	21.3
Temper-2-Ion	48.1 / 57.6	45.5 / 53.8	12.7
Qwen2.5-Coder-1.5B-Instruct	39.0 / 56.1	38.3 / 52.1	7.3

Models are sorted by HumanEval-RS pass@1. Qwen3.6-35B-A3B and Gemma 4 26B-A4B are larger models given for reference. HumanEval-RS (156 tasks) and MBPP-RS (354 tasks) from MultiPL-E at revision 28441b6 go to the model as a chat message with answers up to 1000 tokens, temperature 0.2, top_p 0.95 and 50 answers per task. vLLM took the remaining sampling parameters, top_k and repetition_penalty among them, from the generation_config.json of each model. pass@k comes from the unbiased estimator in the Codex paper. Because the first closed code block of the answer is compiled with the tests, the numbers differ from leaderboards that score code completion. mbpp_67_bell_number has no correct answer in Rust and counts as failed for every model. Every model ran without a system message, using the default of its own chat template, with Qwen2.5-Coder models in their Instruct versions and Qwen3.5, Qwen3.6 and Gemma 4 models without thinking mode. All models were measured under the same conditions. The scripts are open in maylore-ai/rust-evals.

Temper Bench v2 is our own set of 150 Rust tasks at three difficulty levels, scored greedy pass@1.

Training

The model was fine-tuned from Qwen3.5-4B on the same Rust tasks and dialogs as Temper-2-Axon together with a set of hard tasks, then went through reinforcement learning on tasks with tests and a weight merge with the original model.

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer

name = "maylore-ai/Temper-2-Nodel"
tokenizer = AutoTokenizer.from_pretrained(name)
model = AutoModelForCausalLM.from_pretrained(name, dtype="auto", device_map="auto")

messages = [{"role": "user", "content": "Write a Rust function that returns the n-th Fibonacci number."}]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_dict=True, return_tensors="pt").to(model.device)
out = model.generate(**inputs, max_new_tokens=1000)
print(tokenizer.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True))

Without a system message the chat template adds the Temper system prompt. The template opens every assistant turn with an empty thinking block, so the model answers right away without reasoning. The default generation config samples with temperature 0.2 and top_p 0.95, the same settings as in the results above.

The recommended temperature is 0.2.

A GGUF version for llama.cpp, LM Studio and Ollama is in maylore-ai/Temper-2-Nodel-GGUF.

Limitations

Qwen3.5-9B solves 2.8 points more HumanEval-RS tasks on the first try. Nodel's answers became less varied after fine-tuning, and given ten attempts it trails the original Qwen3.5-4B on MBPP-RS (71.1 against 73.4). Asked how the code it has just written works, the model often fails to give a correct explanation, which we plan to fix in the next generations of Temper. Having been trained on chat requests without fill-in-the-middle, it does not work as a drop-in model for inline completion in an editor.

License

Apache 2.0, same as Qwen3.5-4B. Derivative works, including fine-tunes, merges and quantizations, must keep the attributions in NOTICE (Apache 2.0, section 4(d)).