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

bash

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:

bash

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.

Prompt tokens	Early recall	Late recall
10,893	hit	hit
43,578	hit	hit
163,431	hit	hit
250,074	hit	hit

poisonxa/PXA-Coder-35B-PXQ4

PXA Coder 35B