Model reference · open weights

tiny_starcoder_py

LLMs bigcode Text gen 1 build Its own licence terms 220k dl/mo

tiny_starcoder_py is an open-weight language model from bigcode. tiny_starcoder_py (FP32) weighs 328 MB; the smallest configuration that runs it is RTX 3060 12 GB.

  • tiny_starcoder_py is a 164M parameter text-generation model developed by bigcode.
  • It features an 8192 token context length and supports fill-in-the-middle generation.
  • The model is trained on 100 billion tokens of Python data and is released under the bigcode-openrail-m license.

Summary of the bigcode/tiny_starcoder_py model card, 2026-10-01

What it is

Released bybigcode
Released2023-05-15
Parameters164M
VRAM328 MB for the weights

What it runs on

Memory and cards for tiny_starcoder_py (FP32)

328 MBweights, file size
5 MBcache per 1K tokens
518 MBruntime overhead, at least
8,192 tokenscontext max
CardRequests at onceContext maxMemory
8K each
RTX 3060 12 GB256all 8K11.6 GB
RTX 4060 Ti 16 GB347all 8K15.4 GB
RTX 3090 24 GB537all 8K23.4 GB
RTX 4090 24 GB536all 8K23.4 GB
RTX 5090 32 GB719all 8K31.0 GB
L40S 48 GB1000+all 8K44.0 GB
A100 80 GB1000+all 8K78.2 GB
H100 80 GB1000+all 8K78.1 GB
RTX PRO 6000 Blackwell 96 GB1000+all 8K93.8 GB
DGX Spark (GB10) 128 GB unified1000+all 8K107 GB
H200 141 GB1000+all 8K138 GB
B200 180 GB1000+all 8K176 GB
Memory needed at each load
Requests at once8K tokens each
1888 MB
51.1 GB
81.2 GB
161.5 GB
322.2 GB
643.5 GB

One card, with vLLM's small-card settings.

From the model card

What bigcode says about tiny_starcoder_py

Read the model card

This is a 164M parameters model with the same architecture as StarCoder (8k context length, MQA & FIM). It was trained on the Python data from StarCoderData for ~6 epochs which amounts to 100B tokens.

Use

Intended use

The model was trained on GitHub code, to assist with some tasks like Assisted Generation. For pure code completion, we advise using our 15B models StarCoder or StarCoderBase.

Generation

# pip install -q transformers
from transformers import AutoModelForCausalLM, AutoTokenizer

checkpoint = "bigcode/tiny_starcoder_py"
device = "cuda" # for GPU usage or "cpu" for CPU usage

tokenizer = AutoTokenizer.from_pretrained(checkpoint)
model = AutoModelForCausalLM.from_pretrained(checkpoint).to(device)

inputs = tokenizer.encode("def print_hello_world():", return_tensors="pt").to(device)
outputs = model.generate(inputs)
print(tokenizer.decode(outputs[0]))

Fill-in-the-middle

Fill-in-the-middle uses special tokens to identify the prefix/middle/suffix part of the input and output:

input_text = "def print_one_two_three():\n    print('one')\n    \n    print('three')"
inputs = tokenizer.encode(input_text, return_tensors="pt").to(device)
outputs = model.generate(inputs)
print(tokenizer.decode(outputs[0]))

Training

Model

  • Architecture: GPT-2 model with multi-query attention and Fill-in-the-Middle objective
  • Pretraining steps: 50k
  • Pretraining tokens: 100 billion
  • Precision: bfloat16

Hardware

  • GPUs: 32 Tesla A100
  • Training time: 18 hours

Software

License

The model is licensed under the BigCode OpenRAIL-M v1 license agreement. You can find the full agreement here.

Quoted from the model card on Hugging Face. The full card is behind the Hugging Face link above.

Benchmarks

Reported results

As published on the model card: the maker's own numbers, not measured by AxForge.

TaskDatasetMetricScore
text-generationHumanEvalpass@1
© 2026 AxForge · EU-hosted AI infrastructure Pricing Docs Trust Privacy Terms