Instructions to use DedeProGames/Kiyo-65M with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use DedeProGames/Kiyo-65M with Transformers:

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

pipe = pipeline("text-generation", model="DedeProGames/Kiyo-65M")
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("DedeProGames/Kiyo-65M")
model = AutoModelForCausalLM.from_pretrained("DedeProGames/Kiyo-65M", 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 DedeProGames/Kiyo-65M with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/DedeProGames/Kiyo-65M

SGLang

How to use DedeProGames/Kiyo-65M 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 "DedeProGames/Kiyo-65M" \
    --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": "DedeProGames/Kiyo-65M",
		"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 "DedeProGames/Kiyo-65M" \
        --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": "DedeProGames/Kiyo-65M",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Docker Model Runner
How to use DedeProGames/Kiyo-65M with Docker Model Runner:
```
docker model run hf.co/DedeProGames/Kiyo-65M
```
Browse Quantizations to use this model in llama.cpp, Ollama, LM Studio, or any compatible app.

Kiyo-65M is a decoder-only language model pretrained from scratch on 80B tokens drawn from FineWeb-Edu, DCLM-Baseline, FineMath, and Stack-v3-train.

It is the smallest member of the Kiyo family and uses a Llama-style decoder architecture with grouped query attention, RMSNorm, SwiGLU MLPs, and tied input/output embeddings, following the SmolLM2 architecture family and reusing its 49k-token vocabulary. Kiyo-65M scales that recipe down to 15 layers and a 512-dimensional residual stream, roughly halving the parameter count while keeping the same data mixture and training code. It is trained independently from a random initialization, not distilled or pruned from Kiyo-135M.

Model Details

Field	Value
Parameters	64,994,816
Architecture	Llama-style decoder (SmolLM2 architecture)
Layers	15
Hidden size	512
Intermediate size	1,216
Attention heads	8
KV heads	4
Head dimension	64
Attention type	Grouped query attention
Activation	SwiGLU
Normalization	RMSNorm
Positional encoding	RoPE (theta 10,000)
Vocabulary size	49,152
Context length	2,048
Embeddings	Tied input/output embeddings
Training tokens	79,999,533,056
Optimizer steps	152,587
Tokens per optimizer step	524,288
Peak learning rate	2.0e-3
LR schedule	Warmup-stable-decay (1/sqrt)
Weight format	safetensors

Training Data

Source	Domain	Mixture share
FineWeb-Edu	General web text, education-filtered	45.0%
DCLM-Baseline	General web text, high-quality filtered	30.0%
Stack-v3-train	Source code	17.5%
FineMath	Mathematical reasoning	7.5%

Benchmarks

Zero-shot accuracy (%) on the same four benchmarks used for Kiyo-230M-Preview, from the Open SLM Leaderboard.

Benchmark	Kiyo-65M	Veyra2-Apricot-50M-Base	Supra-50M-Base	BananaMind-2-Medium
ARC-Easy	46.51	42.47	45.88	43.81
PIQA	62.30	62.13	62.51	61.86
ARC-Challenge	23.29	23.29	25.00	25.34
HellaSwag	31.98	31.28	31.83	32.43

Usage

pip install -U transformers safetensors torch

import torch
from transformers import AutoTokenizer, AutoModelForCausalLM


model_id = "DedeProGames/Kiyo-65M"


tokenizer = AutoTokenizer.from_pretrained(model_id)


model = AutoModelForCausalLM.from_pretrained(
    model_id,
    torch_dtype=torch.bfloat16 if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else torch.float16,
).cuda().eval()


prompt = "The meaning of life is "
input_ids = tokenizer(prompt, return_tensors="pt").input_ids.to(model.device)


with torch.no_grad():
    output = model.generate(
        input_ids=input_ids,
        max_new_tokens=64,
        do_sample=False,
        repetition_penalty=1.1,
        pad_token_id=tokenizer.eos_token_id,
        eos_token_id=tokenizer.eos_token_id,
    )


print(tokenizer.decode(output[0], skip_special_tokens=True))

Limitations

This is a base model, not instruction-tuned — it continues text rather than following instructions. At 65M parameters and 80B training tokens it still produces fluent, grammatical continuations and remains strong on language completion, but accuracy falls off sharply on quantitative reasoning, multi-step logic, and context tracking, where it sits close to chance on the harder items. The 2,048-token context window also limits long-document use. It can generate incorrect facts and should not be used for high-stakes decisions without verification. Keep a finite generation limit to avoid repetition or drift on long outputs.