Instructions to use Jahirrrr/Klyrune-2B-Coder with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Jahirrrr/Klyrune-2B-Coder with Transformers:

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

pipe = pipeline("text-generation", model="Jahirrrr/Klyrune-2B-Coder")
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("Jahirrrr/Klyrune-2B-Coder")
model = AutoModelForCausalLM.from_pretrained("Jahirrrr/Klyrune-2B-Coder", 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 Jahirrrr/Klyrune-2B-Coder with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/Jahirrrr/Klyrune-2B-Coder

SGLang

How to use Jahirrrr/Klyrune-2B-Coder 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 "Jahirrrr/Klyrune-2B-Coder" \
    --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": "Jahirrrr/Klyrune-2B-Coder",
		"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 "Jahirrrr/Klyrune-2B-Coder" \
        --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": "Jahirrrr/Klyrune-2B-Coder",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

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

Klyrune-2B-Coder

Klyrune-2B-Coder is a small language model built for programming tasks. It builds on Klyrune-2B-General, with a stronger focus on writing code, solving programming problems, and following coding instructions.

We wanted to see how far a model with around 2 billion parameters could go on practical coding benchmarks. We're sharing the results we've measured so far, without treating the model as a finished coding assistant.

DS-1000 results

We evaluated Klyrune-2B-Coder on all 1,000 problems in DS-1000, a benchmark focused on Python data-science programming and real library usage.

Overall accuracy: 24.9% (249 out of 1,000 problems).

Library	Correct	Total	Accuracy
Matplotlib	70	155	45.2%
NumPy	62	220	28.2%
TensorFlow	11	45	24.4%
SciPy	24	106	22.6%
PyTorch	12	68	17.7%
Scikit-learn	20	115	17.4%
Pandas	50	291	17.2%
Overall	249	1,000	24.9%

Matplotlib ended up being the strongest area in this run. NumPy was a little more consistent than some of the other libraries, while Pandas, Scikit-learn, and PyTorch were noticeably harder for the model. The differences across libraries are worth noting: the model often recognizes the kind of operation a problem needs, but still makes mistakes with API details and specific requirements.

How does it compare?

We also wanted to see how it stacks up. Below are published DS-1000 full-benchmark scores from other models, alongside Klyrune's result. We've included some older coding models as well as more recent 2025–2026 models to give the number a bit of context.

Model	Parameters	DS-1000	Result source
DeepSeek-Coder-Base	33B	40.2%	DeepSeek-Coder evaluation
Qwen3-8B	8B	33.1%	Ai2 evaluation
DeepSeek-Coder-Base	6.7B	30.5%	DeepSeek-Coder evaluation
DeepSeek-Coder-Base	5.7B	27.7%	DeepSeek-Coder evaluation
Klyrune-2B-Coder (this model)	~2B	24.9%	EvalScope 1.14.1 (our run)
CodeGeeX2	6B	22.9%	DeepSeek-Coder evaluation
CodeLlama-Base	7B	22.1%	DeepSeek-Coder evaluation
Olmo Hybrid	7B	21.1%	Ai2 evaluation
Olmo 3	7B	20.2%	Ai2 evaluation
DeepSeek-Coder-Base	1.3B	16.2%	DeepSeek-Coder evaluation

It's encouraging to see a 2B model land in roughly the same range as some larger models in these published results. This isn't a controlled head-to-head comparison, though. The scores come from different evaluation setups, with potentially different prompts, generation limits, dependency versions, and scoring implementations. They are best read as context, not as proof that one model outperforms another under identical conditions.

Evaluation setup

The Klyrune results were collected with EvalScope 1.14.1 using its native backend and greedy decoding (do_sample=False). Each of the seven DS-1000 library subsets was evaluated in full, without a sample limit, and the overall number was calculated from the combined correct answers.

The subsets were run separately, and the maximum generation-token setting was not identical across every run. The logs completed successfully, but we haven't yet independently reproduced the full score with one unified configuration or a matched evaluation of the comparison models. The EvalScope run configuration also had its external sandbox option disabled. We recommend treating the reported number as an experimental result until the execution and scoring path has been independently checked.

PolyCodeBench Hard v1.0 — internal benchmark

Alongside DS-1000, we ran PolyCodeBench Hard v1.0, an internal benchmark we put together to look at a different side of coding ability: understanding code, spotting bugs, and reasoning about programming behavior. It has 200 multiple-choice questions covering Python, JavaScript, TypeScript, and Go.

We tested Klyrune against three other small models on the same set of questions, using the same evaluation setup. This time, instead of asking the models to generate an answer and trying to parse it afterward, we scored the A/B/C/D choices directly from model logits, with four rotations of the answer positions. This avoids the truncated or badly formatted responses that affected our earlier experimental runs.

Model	Correct	Accuracy
Klyrune-2B-Coder (~2B)	143 / 200	71.5%
Qwen3-4B (4B, non-thinking)	142 / 200	71.0%
Qwen2.5-Coder-3B-Instruct (3B)	127 / 200	63.5%
Qwen2.5-Coder-1.5B-Instruct (1.5B)	116 / 200	58.0%

Klyrune finished first in this run, but only by one question over Qwen3-4B. We think that's an interesting result for a model this size, rather than a reason to claim it's a stronger coding model overall.

Here's how Klyrune performed across the four areas we tested:

Category	Correct	Accuracy
Algorithmic reasoning	38 / 40	95.0%
API and library semantics	39 / 40	97.5%
Bug detection	46 / 60	76.7%
Code output prediction	20 / 60	33.3%

The result is a bit mixed. Klyrune did well on questions about algorithms and API behavior, while predicting exactly what a piece of code would print was much harder. That's a useful weakness for us to keep in mind as we work on the model.

A note on the benchmark: PolyCodeBench is our own internal evaluation, not an independently established or externally validated benchmark. The 200 questions come from 50 related problem families, and the non-output-prediction items still need a full independent review of their answer keys. It measures multiple-choice coding reasoning, not whether generated code passes tests or whether a model can complete real software engineering tasks. We ran all four models under the same protocol, but the small lead over Qwen3-4B should not be taken as evidence of a general performance advantage.