Instructions to use BlazingCustoms/pybytecode-v3-1.5b with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use BlazingCustoms/pybytecode-v3-1.5b with Transformers:

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

pipe = pipeline("text-generation", model="BlazingCustoms/pybytecode-v3-1.5b")
messages = [
    {"role": "user", "content": "Who are you?"},
]
pipe(messages)

# Load model directly
from transformers import AutoTokenizer, AutoModelForCausalLM

tokenizer = AutoTokenizer.from_pretrained("BlazingCustoms/pybytecode-v3-1.5b")
model = AutoModelForCausalLM.from_pretrained("BlazingCustoms/pybytecode-v3-1.5b", 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=40)
print(tokenizer.decode(outputs[0][inputs["input_ids"].shape[-1]:]))

Notebooks
Google Colab
Kaggle
Local Apps Settings

llama.cpp

How to use BlazingCustoms/pybytecode-v3-1.5b with llama.cpp:

Install (macOS, Linux)

curl -LsSf https://llama.app/install.sh | sh
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf BlazingCustoms/pybytecode-v3-1.5b:F16
# Run inference directly in the terminal:
llama cli -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Install from WinGet (Windows)

winget install llama.cpp
# Start a local OpenAI-compatible server with a web UI:
llama serve -hf BlazingCustoms/pybytecode-v3-1.5b:F16
# Run inference directly in the terminal:
llama cli -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Use pre-built binary

# Download pre-built binary from:
# https://github.com/ggerganov/llama.cpp/releases
# Start a local OpenAI-compatible server with a web UI:
./llama-server -hf BlazingCustoms/pybytecode-v3-1.5b:F16
# Run inference directly in the terminal:
./llama-cli -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Build from source code

git clone https://github.com/ggerganov/llama.cpp.git
cd llama.cpp
cmake -B build
cmake --build build -j --target llama-server llama-cli
# Start a local OpenAI-compatible server with a web UI:
./build/bin/llama-server -hf BlazingCustoms/pybytecode-v3-1.5b:F16
# Run inference directly in the terminal:
./build/bin/llama-cli -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Use Docker

docker model run hf.co/BlazingCustoms/pybytecode-v3-1.5b:F16

LM Studio
Jan

vLLM

How to use BlazingCustoms/pybytecode-v3-1.5b with vLLM:

Install from pip and serve model

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

Use Docker

docker model run hf.co/BlazingCustoms/pybytecode-v3-1.5b:F16

SGLang

How to use BlazingCustoms/pybytecode-v3-1.5b 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 "BlazingCustoms/pybytecode-v3-1.5b" \
    --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": "BlazingCustoms/pybytecode-v3-1.5b",
		"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 "BlazingCustoms/pybytecode-v3-1.5b" \
        --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": "BlazingCustoms/pybytecode-v3-1.5b",
		"messages": [
			{
				"role": "user",
				"content": "What is the capital of France?"
			}
		]
	}'

Ollama
How to use BlazingCustoms/pybytecode-v3-1.5b with Ollama:
```
ollama run hf.co/BlazingCustoms/pybytecode-v3-1.5b:F16
```

Unsloth Studio

How to use BlazingCustoms/pybytecode-v3-1.5b with Unsloth Studio:

Install Unsloth Studio (macOS, Linux, WSL)

curl -fsSL https://unsloth.ai/install.sh | sh
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for BlazingCustoms/pybytecode-v3-1.5b to start chatting

Install Unsloth Studio (Windows)

irm https://unsloth.ai/install.ps1 | iex
# Run unsloth studio
unsloth studio -H 0.0.0.0 -p 8888
# Then open http://localhost:8888 in your browser
# Search for BlazingCustoms/pybytecode-v3-1.5b to start chatting

Using HuggingFace Spaces for Unsloth

# No setup required
# Open https://huggingface.co/spaces/unsloth/studio in your browser
# Search for BlazingCustoms/pybytecode-v3-1.5b to start chatting

How to use BlazingCustoms/pybytecode-v3-1.5b with Pi:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Configure the model in Pi

# Install Pi:
npm install -g @mariozechner/pi-coding-agent
# Add to ~/.pi/agent/models.json:
{
  "providers": {
    "llama-cpp": {
      "baseUrl": "http://localhost:8080/v1",
      "api": "openai-completions",
      "apiKey": "none",
      "models": [
        {
          "id": "BlazingCustoms/pybytecode-v3-1.5b:F16"
        }
      ]
    }
  }
}

Run Pi

# Start Pi in your project directory:
pi

OpenClaw new

How to use BlazingCustoms/pybytecode-v3-1.5b with OpenClaw:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Configure OpenClaw

# Install OpenClaw:
npm install -g openclaw@latest
# Register the local server and set it as the default model:
openclaw onboard --non-interactive --mode local \
  --auth-choice custom-api-key \
  --custom-base-url http://127.0.0.1:8080/v1 \
  --custom-model-id "BlazingCustoms/pybytecode-v3-1.5b:F16" \
  --custom-provider-id llama-cpp \
  --custom-compatibility openai \
  --custom-text-input \
  --accept-risk \
  --skip-health

Run OpenClaw

openclaw agent --local --agent main --message "Hello from Hugging Face"

Docker Model Runner
How to use BlazingCustoms/pybytecode-v3-1.5b with Docker Model Runner:
```
docker model run hf.co/BlazingCustoms/pybytecode-v3-1.5b:F16
```

Lemonade

How to use BlazingCustoms/pybytecode-v3-1.5b with Lemonade:

Pull the model

# Download Lemonade from https://lemonade-server.ai/
lemonade pull BlazingCustoms/pybytecode-v3-1.5b:F16

Run and chat with the model

lemonade run user.pybytecode-v3-1.5b-F16

List all available models

lemonade list

Hermes Agent

How to use BlazingCustoms/pybytecode-v3-1.5b with Hermes Agent:

Start the llama.cpp server

# Install llama.cpp:
brew install llama.cpp
# Start a local OpenAI-compatible server:
llama serve -hf BlazingCustoms/pybytecode-v3-1.5b:F16

Configure Hermes

# Install Hermes:
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash
hermes setup
# Point Hermes at the local server:
hermes config set model.provider custom
hermes config set model.base_url http://127.0.0.1:8080/v1
hermes config set model.default BlazingCustoms/pybytecode-v3-1.5b:F16

Run Hermes

hermes

Atomic Chat

pybytecode-v3-1.5b / harness /README.md

coolblaze03

Add files using upload-large-folder tool

0b19a1b verified 5 days ago

preview code

Raw

History Blame Contribute Delete

8.41 kB

PyBytecode evaluation harness

Grades Python 3.12 decompilations under a sound oracle: recompile the prediction and require the resulting code object to be byte-identical to the reference's, recursively, including docstrings and co_exceptiontable. A pass is a proof, not a plausibility judgement.

Its limits are real and are documented in ../ORACLE-LIMITS.md: a 0.33% false-reject floor on foreign .pyc, a hard dependency on matching the producer's optimization level, and the fact that the 100% pre-flight this harness prints proves far less than it looks like it does. Read that before quoting any number from here.

Everything here runs from a fresh clone with the Python standard library alone. No model, no GPU, no network, no API key, no PyLingual, and no path outside the clone. Verified — see Fresh-clone verification below.

Requirements

To do this	You need
Grade cached generations (every published number)	CPython 3.12.x. Nothing else.
Generate new predictions	the above + any OpenAI-compatible server
Rebuild a benchmark from its source dataset	the above + `pip install -r requirements.txt` + authenticated `gh`
Compare against PyLingual	the above + the optional extra (`requirements-pylingual.txt`)

CPython 3.12 is not a preference. The benchmark is 3.12 bytecode; on 3.11 or 3.13 the reference .pyc files will not compare and pre-flight will fail loudly rather than score silently.

Configuration is environment-only — PYBYTECODE_ENDPOINT, PYBYTECODE_MODEL, PYBYTECODE_API_KEY (see config.py). Nothing is hard-coded to a machine.

Reproduce every published number, from cache

No model, no GPU, no network. The expensive part — the generations — is cached in this bundle, so every number below is re-derivable for the cost of a few CPU-minutes.

cd harness
B=../benchmarks/csn-3.12-licensed/bench.jsonl
G=../generations

# 1. Prove the harness is sound before believing any score it prints.
python3 grade.py --bench $B --self-test-only --out ../results/selftest_csn.json

# 2. Full scoring: tuned greedy, untuned-base control, verified best-of-N,
#    with repo-clustered confidence intervals and per-row verdicts.
python3 analyze_scores.py --bench $B \
    --greedy  $G/gen_v3_csn600.jsonl \
    --samples $G/boN_v3_csn600.jsonl \
    --base    $G/gen_base_csn600.jsonl \
    --out ../results/scores_csn600.json --rows-out ../results/rows_csn600.jsonl

../results/scores_csn600.json holds the aggregates and intervals; ../results/rows_csn600.jsonl holds a per-row verdict for all 600 rows — repo, function, commit SHA, SPDX, instruction count, whether tuned greedy certified, whether the untuned base certified, and the index of the first passing sample. Every headline number is recomputable from that file alone.

The MBPP set is graded the same way:

python3 grade.py --bench ../benchmarks/mbpp-ood/bench.jsonl \
                 --self-test-only --out ../results/selftest_mbpp.json

Confidence intervals are repo-clustered

Rows from the same repository are not independent — shared author, house style, shared helpers — so a plain binomial interval understates uncertainty. analyze_scores.py resamples repositories with replacement (the cluster bootstrap, 10,000 draws) and reports the 2.5th and 97.5th percentiles, alongside the naive binomial interval and the design effect so the cost of clustering is visible rather than assumed.

This is meaningful here only because the benchmark caps any repository at ~1% of rows. On the superseded 400-row set, one repository supplied 15% and a clustered interval would have been the only honest one to quote — and none was.

Generate predictions (needs a model)

export PYBYTECODE_ENDPOINT=http://localhost:1234/v1
export PYBYTECODE_MODEL=pybytecode-v3-1.5b

python3 generate.py --bench ../benchmarks/csn-3.12-licensed/bench.jsonl --out gen.jsonl
python3 generate.py --bench ../benchmarks/csn-3.12-licensed/bench.jsonl \
                    --out boN.jsonl --temperature 0.8 --samples 32     # for best-of-N
python3 grade.py --bench ../benchmarks/csn-3.12-licensed/bench.jsonl \
                 --gen gen.jsonl --out ../results/mine.json

generate.py is resumable: an interrupted run is completed by re-running the same command.

PyLingual — optional, user-installed, never vendored

PyLingual is GPL-3.0-only. It is not a dependency of this harness and is not included in this repository in any form. We import exactly one symbol from it, pylingual.equivalence_check.compare_pyc, and only at grading time, so that the head-to-head comparison uses their definition of a perfect decompilation rather than our reimplementation of it. Nobody can say we loosened their bar.

Without it: dual_oracle.py runs and reports pylingual_available: false, with their-oracle columns null — explicitly absent, never silently zeroed. grade.py --oracle theirs exits with an explanation. Everything else is unaffected.

Install instructions and the exact commit we measured: requirements-pylingual.txt.

The self-tests, and why they can refuse

Two gates run before any score is printed:

Pre-flight — grade every reference label against itself. A byte-perfect model must score 100%. Anything less means the harness is broken, not that the model is bad. It is trivial by construction and is NOT evidence of soundness: it compares compile(x) with compile(x), so any deterministic function of the source scores 100%, including a stub that ignores the bytecode. It detects a broken harness (mismatched .pyc, wrong Python minor, corrupt row) and nothing more. Soundness evidence is the mutation test and the 18 blind-spot probes — see ../ORACLE-LIMITS.md §1.
Mutation test — corrupt each label (swap +/-, flip a comparison, break a return) and confirm the oracle kills it. A grader that passes mutants is a stub and its scores are noise.

If either is below 100% the command refuses to print a score. That is intended behaviour.

Mutation candidates that do not change the program's AST are discarded rather than counted, so a comment-only rewrite cannot be mistaken for a surviving mutant. This matters: the original harness generated return None → return None #None and would have scored that as a survivor. It reported 131/131 only because no row in its sample had a bare return None; the new 600-row benchmark has three, and the un-filtered generator scored 97.48% and correctly refused to run. The fix is in the mutation generator; the oracle was never loosened.

Measured on the current benchmarks:

Benchmark	Pre-flight	Mutation kill rate
`csn-3.12-licensed` (n=600)	600/600 = 100%	116/116 = 100%
`mbpp-ood` (n=383)	383/383 = 100%	199/199 = 100%

Fresh-clone verification

Performed 2026-08-04. git clone into a scratch directory, no PYBYTECODE_* variables set, no PyLingual installed (ModuleNotFoundError), no model running, working directory not the original path:

1. self-test csn-3.12-licensed   PRE-FLIGHT 600/600 = 100.0%   MUTATION 116/116 = 100.0%   SOUND
2. dual_oracle on cached CSN     n=400  ours 335 = 83.75%   pylingual_available: false
3. bestofn_grade on cached CSN   greedy 335   certified@32 373 = 93.25%

Identical to the published values. Git LFS is required to materialise the cached generations — see ../RELEASE-BLOCKERS.md, which records the state of the LFS objects on the remote.

Files

config.py            paths + endpoint; the only environment-aware module
common.py            oracles, fence stripping, pre-flight, mutation test
grade.py             score under one oracle (ours by default), self-tests first
dual_oracle.py       score under both oracles; degrades gracefully without PyLingual
bestofn_grade.py     verified best-of-N from cached samples
generate.py          the only script that needs a model
pybytecode_core/     verify.py + rep.py, copied verbatim from scripts/pybytecode/

pybytecode_core/ is a byte-identical copy so the harness is self-contained. Verify it:

sha256  45ca921f86c73622d5b46295b9264e4a68bd697dce94e27a786c73f4416319b9  verify.py
sha256  1ba81c307c72e83d2c6a6eceb9936bf3f13645d267df3c7c676d421b9b2f43d9  rep.py