Request access to the EUGEN 160M research checkpoint

Access is reviewed and approved individually. Please give your email address and your LinkedIn profile and tell us what you plan to do with the checkpoint. Before approving, we may contact you on LinkedIn to confirm your identity and purpose. Hugging Face also shares your Hub username and account email with us. Your data is handled as described in Section 8 (Personal data) of the Research Use Terms.

This repository contains an intermediate training checkpoint of EUGEN 160M, shared only for non-commercial scientific research and evaluation under the EUGEN 160M Research Use Terms (LICENSE.md). Requests are reviewed manually; access may be revoked if the terms are not respected.

EUGEN 160M — research checkpoint (step 204,000)

This is an intermediate training checkpoint of EUGEN 160M, not a finished base model. Training is ongoing; capabilities, behaviour and results will change in later checkpoints. All results below describe this checkpoint only.

EUGEN 160M is a small language model for code, trained from scratch. It has 164.5 million parameters (the name is rounded) and runs locally — on a single consumer GPU or on an ordinary CPU.

This repository contains the checkpoint from training step 204,000 together with the complete generation stack, so that the checkpoint can be evaluated in the same way it is served:

Capability	What it does
Autocomplete	Completes the current line as you type
Next line	Proposes the next line of code
Fill-in-the-middle (FIM)	Fills a gap using the code before and after the cursor
Python → C++ translation	Translates a Python function to C++; every candidate is compiled and run against tests before it is returned

Access is granted individually, for non-commercial research and evaluation only — see Research Use Terms.

Results at step 204,000

Benchmark	Setting	Result
HumanEval (164 tasks)	one attempt per task (greedy, pass@1)	22.6%

The full evaluation — further benchmarks, comparisons with other small code models, and the training history — is published in the EUGEN 160M training report.

Speed

Generation speed for a single user, 128 new tokens, Q8_0 weights:

Hardware	Tokens per second	Measured
AMD Ryzen 9 9900X, CPU only, 8 threads (llama.cpp engine)	364	22 Oct 2026, earlier checkpoint of the same model¹
AMD Ryzen 9 9900X, CPU only, through the server	310	22 Oct 2026, earlier checkpoint¹
NVIDIA Quadro RTX 5000	403	22 Oct 2026, earlier checkpoint¹
NVIDIA Tesla V100S	429	22 Oct 2026, earlier checkpoint¹
Intel Core i9-9900K (iMac, macOS 15.4), CPU only, 8 threads (llama.cpp engine)	176	25 Oct 2026, this file

¹ Identical architecture and file format, so generation speed is the same.

Requirements and tested environments

	Tested	Minimum
Operating system	Linux (Ubuntu 24.04); macOS 15.4 (Intel)	Linux or macOS. Windows has not been tested.
CPU	AMD Ryzen 9 9900X (Linux), Intel Core i9-9900K (macOS)	64-bit CPU, about 1 GB free RAM
GPU (optional)	NVIDIA Quadro RTX 5000, NVIDIA Tesla V100S (Linux, CUDA 12)	NVIDIA GPU with CUDA 12.x. Not required: CPU-only works. Apple Metal has not been tested.
Inference engine	llama.cpp at commit `a02c7f5` with the patch in this repository	same
Stack	Python 3.12 (Linux), 3.14 (macOS); aiohttp	Python 3.10 or newer
Translation verifier	g++ 13 with bubblewrap sandbox (Linux); Apple clang 17 with a resource-limited subprocess (macOS)	a C++17 compiler; bubblewrap recommended on Linux
Disk	—	about 180 MB for the checkpoint and the stack

The stack has been checked to give identical outputs, field by field, to the reference deployment: 39 completion requests (inline, next line, block and fill-in-the-middle) and 3 verified translations, with only timing fields differing.

Files

File	What it is
`eugen-160m-step204000-q8_0.gguf`	the checkpoint at step 204,000, Q8_0, 169 MB
`llama.cpp/eugen-tokenizer.patch`	tokenizer patch for llama.cpp (adds the EUGEN pre-tokenizer)
`stack/server.py`	gateway: completion and verified translation over HTTP
`stack/eugen_stack/`	completion logic (fill-in-the-middle, name monitor, scope cutting, repetition guard) and the C++ translation verifier
`stack/README.md`	full description of the stack, its settings and request fields
`LICENSE.md`	Research Use Terms

Quick start

1. Build the inference engine

# run inside the downloaded copy of this repository
git clone https://github.com/ggml-org/llama.cpp llama.cpp-src
cd llama.cpp-src
git checkout a02c7f58c1c335f5375bf81f174b9a58cce939af
git apply ../llama.cpp/eugen-tokenizer.patch

# CPU only (Linux and macOS)
cmake -B build -DGGML_METAL=OFF -DLLAMA_CURL=OFF -DCMAKE_BUILD_TYPE=Release
cmake --build build -j --target llama-server llama-completion

# NVIDIA GPU (CUDA, Linux)
cmake -B build-cuda -DGGML_CUDA=ON -DLLAMA_CURL=OFF -DCMAKE_BUILD_TYPE=Release
cmake --build build-cuda -j --target llama-server llama-completion

Quick check:

./build/bin/llama-completion -m ../eugen-160m-step204000-q8_0.gguf -p "def is_palindrome(s):" -n 9 --temp 0 2>/dev/null
# def is_palindrome(s):
#     return s == s[::-1]

2. Start the model server

# CPU
./build/bin/llama-server -m ../eugen-160m-step204000-q8_0.gguf \
  --override-kv qwen3.context_length=int:2048 -c 2048 --host 127.0.0.1 --port 8080

# GPU (all layers on the GPU)
./build-cuda/bin/llama-server -m ../eugen-160m-step204000-q8_0.gguf \
  --override-kv qwen3.context_length=int:2048 -c 2048 -ngl 99 -fa on --host 127.0.0.1 --port 8080

3. Start the verifier and the gateway

cd ../stack
pip install -r requirements.txt
python3 -m eugen_stack.translate.server &           # C++ verifier on 127.0.0.1:18500
python3 server.py --upstream http://127.0.0.1:8080  # gateway on 127.0.0.1:18400

Both bind to 127.0.0.1 and have no authentication; they are meant for local use.

4. Try it

# Autocomplete (rest of the line)
curl -s http://127.0.0.1:18400/v1/complete -H 'Content-Type: application/json' \
  -d '{"prompt": "def add(a, b):\n    return", "mode": "inline", "max_tokens": 16}'

# Next line
curl -s http://127.0.0.1:18400/v1/complete -H 'Content-Type: application/json' \
  -d '{"prompt": "import os\n\ndef list_files(path):\n", "mode": "next_line", "max_tokens": 64}'

# Fill-in-the-middle (code before and after the cursor)
curl -s http://127.0.0.1:18400/v1/complete -H 'Content-Type: application/json' \
  -d '{"prompt": "def mean(xs):\n    ", "suffix": "\n    return total / len(xs)\n", "mode": "inline", "max_tokens": 32}'

# Python -> C++ translation, compiled and tested before it is returned
curl -s http://127.0.0.1:18400/v1/translate_verified -H 'Content-Type: application/json' \
  -d '{"code": "def count_vowels(s: str) -> int:\n    return sum(1 for c in s if c in \"aeiou\")\n", "target": "cpp"}'

The translation response reports whether the C++ code compiled, whether it passed the tests, whether its outputs match the Python function on the generated inputs, and the measured speed-up.

Intended use

Research on small code models: evaluation, benchmarking, analysis of model behaviour.
Experiments with local code assistance, on CPU or GPU.

Out of scope

Commercial products or services, or any production use.
Redistribution of the weights or of weights derived from them.
Use without human review of the generated code.

Limitations

This is an intermediate checkpoint of a small model. It makes mistakes, including plausible-looking code that is wrong.
Trained mainly on Python; quality in other languages is lower. Translation is supported from Python to C++ only, and this card reports no separate benchmark for it.
It is a completion model, not a chat or instruction-following assistant.
Always run tests on generated code. The translation tool does this automatically; the other modes do not.

Access

Sign in to Hugging Face and fill in the access form at the top of this page, including your email address, your LinkedIn profile and the purpose of use.
Each request is reviewed by hand. Before approving, we may contact you on LinkedIn to confirm your identity and purpose.
You will be notified by email when the request is approved.
Access is personal. If you need access for a colleague, they should submit their own request.

Citation

@misc{cwirlej2026eugen160m,
  author       = {Jakub Ćwirlej},
  title        = {EUGEN 160M: research checkpoint at step 204,000},
  year         = {2026},
  howpublished = {\url{https://huggingface.co/JakCwi/Eugen-160m}},
  note         = {Intermediate training checkpoint, not a finished base model}
}

Contact

Jakub Ćwirlej · jakub.cwirlej@gmail.com · https://jakubcwirlej.com

Downloads last month: -

GGUF

Hardware compatibility

8-bit