PXA Coder 35B
CODE. BUILD. AUTOMATE.
This model does not run on stock llama.cpp, LM Studio, ollama, or text-generation-webui. PXQ4 is a PXA format. You need our engine: https://github.com/poisonxa16/pxq_llama.cpp If you want something that runs anywhere, this is not that model. If you want 35B on a 24 GB card, read on.
1. Meet PXA Coder
PXA Coder is built to code, think, and actually get shit done.
We're introducing PXA Coder, our next-generation coding model from PXA Network, built for developers who need more than autocomplete and surface-level answers.
Under the hood, PXA Coder brings together capabilities from Qwen 3.6 and Qwen 3.8, merged and further trained using the larger "big brother" model as a teacher. We used that foundation to push the model toward stronger coding instincts, better reasoning, and more reliable behavior when tasks get long and complicated.
The result isn't meant to be another model that spits out a code snippet and calls it a day.
PXA Coder is built for the hard stuff: large codebases, complicated debugging, multi-file changes, architecture decisions, agentic workflows, and problems where the first answer usually isn't the right one.
It's built to stay locked onto the goal across long sessions instead of forgetting what it was doing halfway through.
Whether you're building an app from scratch, hunting down a nasty bug, refactoring a mess of legacy code, or handing an AI agent an entire project to work through, PXA Coder is built to keep moving.
2. What PXA Coder Brings
Built From a Strong Foundation
PXA Coder combines the strengths of Qwen 3.6 and Qwen 3.8, then takes that foundation further through additional training guided by the larger model.
The idea is simple: take what already works, push it harder, and tune it specifically toward the kind of coding and reasoning workflows we actually care about.
Built for Real Coding
PXA Coder isn't just here to explain code. It's built to write it, modify it, debug it, and build with it.
From a single function to an entire application, PXA Coder is designed to work with real-world development workflows.
Long-Horizon Agentic Work
Give it a task that takes 5 minutes — or a task that takes 5 hours.
PXA Coder is designed to maintain context, track objectives, work through multiple steps, and recover when things don't go according to plan.
Handles the Hard Stuff
Complex algorithms. Difficult bugs. Weird edge cases. Massive codebases.
PXA Coder is designed for problems where "just generate some code" isn't enough. It can break complicated problems down, reason through them, and work toward a solution without constantly losing the plot.
Multi-File & Codebase-Aware
Real projects aren't one Python file.
PXA Coder is built to work across files, understand how pieces of a project connect, make coordinated changes, refactor existing code, and chase bugs across an entire codebase.
Built for Agents
PXA Coder is designed to work inside agentic coding environments where the model can inspect files, use tools, run commands, make changes, test its work, and iterate.
Think → Build → Test → Fix → Repeat.
Stays Locked In
One of the biggest problems with long AI sessions is drift.
The task starts here.
Twenty steps later, the model has forgotten why it started.
PXA Coder is designed around avoiding that problem — keeping the objective, context, and previous work in view throughout the process.
3. Performance & Design Philosophy
PXA Coder isn't built around giving the flashiest answer in the first five seconds.
It's built around getting to the right answer.
The model is designed for sustained coding sessions where problems evolve, requirements change, bugs appear, and the first solution needs to be thrown out and rebuilt.
Its focus is simple:
Better reasoning. Better code. Better execution.
The model combines the underlying capabilities of its Qwen-based foundation with additional training designed to make it more useful as a dedicated coding model.
The focus is sustained performance: reasoning through difficult problems, navigating larger projects, maintaining context, and continuing to work when the first solution doesn't survive contact with the real codebase.
PXA Coder is built to go beyond generating snippets and become an actual coding engine — capable of working through complex projects, making decisions, testing those decisions, and adapting when something breaks.
The goal isn't to make an AI that looks like a developer.
The goal is to build one that can actually build.
Specifications
| Parameters | 34.7 B total, mixture-of-experts |
| Architecture | Qwen MoE, hybrid attention (linear + full, 1-in-4) |
| Context | 262,144 trained |
| Vocabulary | 248,320 |
| Modality | text + vision (ships with an mmproj) |
| Quantisation | PXQ4, 19 GB on disk |
| Licence | Apache 2.0 |
Files
| File | Size | What it is |
|---|---|---|
PXA-Coder-35B-v2-PXQ4.gguf |
19 GB | the model |
mmproj-PXA-Coder-35B-v2-f16.gguf |
899 MB | vision projector — only needed for image input |
Running it
git clone https://github.com/poisonxa16/pxq_llama.cpp
cd pxq_llama.cpp
cmake -B build -S . -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES="70;80;86;89;90"
cmake --build build -j --target llama-server
./build/bin/llama-server \
-m PXA-Coder-35B-v2-PXQ4.gguf \
--mmproj mmproj-PXA-Coder-35B-v2-f16.gguf \
-ngl 99 -c 32768
Drop --mmproj if you only want text. Lower -c if you are tight on VRAM — the KV cache,
not the weights, is what will run you out.
Building on a machine with no GPU present? The CUDA toolkit's driver stub has to be on
the link line or you will get undefined reference to cuMemCreate and friends. Paths spelled
out in full so nothing depends on your shell:
sudo ln -sf /usr/local/cuda/lib64/stubs/libcuda.so /usr/local/cuda/lib64/stubs/libcuda.so.1
cmake -B build -S . -DGGML_CUDA=ON -DCMAKE_CUDA_ARCHITECTURES=60 -DLLAMA_CURL=OFF \
-DCMAKE_EXE_LINKER_FLAGS="-L/usr/local/cuda/lib64/stubs -Wl,-rpath-link,/usr/local/cuda/lib64/stubs" \
-DCMAKE_SHARED_LINKER_FLAGS="-L/usr/local/cuda/lib64/stubs -Wl,-rpath-link,/usr/local/cuda/lib64/stubs"
cmake --build build -j --target llama-server llama-cli
Why PXQ4
PXQ4 stores weights as 64-row panels with a per-row fp16 anchor and a shared sub-block scale, rather than per-block scales the way K-quants do. On this model that is 19 GB against 69 GB at f16 — 35B fits on a single 24 GB card with room for context.
The format is the reason for the engine requirement. It is not a repackaged GGUF quant; the dequant and matmul kernels are ours.
Safety
This model has had its refusal behaviour deliberately reduced. It will attempt requests that a stock instruct model declines.
That is the intended design — it exists to be a working tool that does not refuse benign
technical work because a variable is named kill_process. It is not a safety-aligned
assistant, it has no guardrails you can rely on, and you are responsible for what you do
with it and for whatever you put in front of users.
Evaluation status
Being straight about this, because the model is new:
Coding, reasoning, instruction following, vision — exercised and working.
Long-context retention is measured, and it holds. Needle-in-a-haystack against the served model, with the fact placed both early and late in the window:
Prompt tokens Early recall Late recall 10,893 hit hit 43,578 hit hit 163,431 hit hit 250,074 hit hit 100% at every depth tested, up to 250k tokens.
Agentic and multi-file workflows are a design target, not yet a benchmarked result. If you put it through a real agent loop, we want the numbers — including bad ones.
Credits
Qwen-based foundation, Apache 2.0. Quantisation format, engine, and post-training by PXA Network. Licensed Apache 2.0; this is a modified work.
PXA Coder — Built by PXA Network for developers, builders, engineers, and anyone who'd rather ship than stare at a blank terminal.
Your ideas. Our intelligence. Real results.
- Downloads last month
- 140
We're not able to determine the quantization variants.