llama.cpp/opencode/Qwen 3.6 Golden Config.md

llama.cpp-opencode-Qwen 3.6 golden config.md

Tools and versions

• llama.cpp: build 9859 (4fc4ec554), Windows x64 (CUDA 13) + CUDA 13.3 DLLs
• OpenCode: 1.17.13, opencode-windows-x64.zip
• Model: bartowski/Qwen_Qwen3.6-35B-A3B-Q5_K_L.gguf, from commit 848e3a3
• Chat template: froggeric_Qwen-Fixed-Chat-Templates.jinja.txt, from commit d2c8dff

Vital info

• MoBo: MSI MS-7D33
• Processor: Intel(R) Core(TM) i7-14700KF (3.40 GHz)
• Installed RAM: 2 x 16G G.Skill Trident Z5 RGB DDR5-6400 CL32-39-39-102
• GPU: NVIDIA GeForce RTX 4070 Ti SUPER 16G (MSI)
• GeForce Game Ready driver: v610.62
• Edition: Windows 11 Pro
• Version: 25H2
• OS build: 26200.8655

llama.cpp command

.\llama-server `
--api-key sk-1234 `
--batch-size 1024 `
--cache-type-k q8_0 `
--cache-type-v q8_0 `
--jinja `
--chat-template-file "D:/inference/models/chat_templates/froggeric_Qwen-Fixed-Chat-Templates.jinja.txt" `
--chat-template-kwargs '{"preserve_thinking":true, "auto_disable_thinking_with_tools":false}' `
--checkpoint-min-step 32768 `
--cont-batching `
--ctx-checkpoints 64 `
--flash-attn on `
--fit on `
--fit-ctx 131072 `
--fit-target 2560 `
--frequency-penalty 0.0 `
--host 192.168.1.117 `
--log-verbosity 4 `
--min-p 0.0 `
--model "D:/inference/models/bartowski/Qwen/Qwen3.6-35B-A3B/Q5_K_L.gguf" `
--n-predict 65536 `
--no-kv-unified `
--no-mmproj `
--no-mmap `
--parallel 1 `
--port 8089 `
--presence-penalty 0.0 `
--reasoning on `
--reasoning-budget 8192 `
--reasoning-budget-message "reasoning cap hit - stop. Synthesize and respond with your best answer from accumulated reasoning." `
--reasoning-format deepseek `
--reasoning-preserve `
--repeat-penalty 1.0 `
--spec-type none `
--temp 1.0 `
--threads 8 `
--threads-batch 16 `
--threads-http 2 `
--top-k 20 `
--top-p 0.95 `
--ubatch-size 64

opencode.jsonc

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "llama.cpp": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "llama-server",
      "options": {
        "apiKey": "sk-1234",
        "baseURL": "http://192.168.1.117:8089/v1",
      },
      "models": {
        "Qwen3.6-35B-A3B": {
          "id": "Qwen3.6-35B-A3B",
          "name": "Qwen3.6 35B-A3B",
          "description": "Qwen vision-language model for visual reasoning, documents, and agent tasks",
          "family": "Qwen3",
          "attachment": true,
          "interleaved": {
            "field": "reasoning_content"
          },
          "knowledge": "2025-04",
          "limit": {
            "context": 131056,
            "input": 131056,
            "output": 16384,
          },
          "modalities": {
            "input": [
              "text",
            ],
            "output": [
              "text",
            ],
          },
          "open_weights": true,
          "reasoning_options": [
            {
              "type": "toggle",
            },
          ],
          "reasoning": true,
          "structured_output": true,
          "temperature": true,
          "tool_call": true,
          "last_updated": "2026-04-17",
          "release_date": "2026-04-17",
        },
      },
    },
  },
  "model": "llama.cpp/Qwen3.6-35B-A3B",
}

xample session.md

Example coding prompt, ONE SHOT?!

Refactor the following to use fewer operations, and to be easier to understand for the average reviewer

def generate_search_path_list(default_file, git_root, command_line_file):
    files = []
    files.append(Path.home() / default_file)  # homedir

    xdg_config_home = os.environ.get("XDG_CONFIG_HOME")

    if not xdg_config_home:
        xdg_config_home = Path.home() / ".config"
    else:
        xdg_config_home = Path(xdg_config_home)

    xdg_aider_dir = xdg_config_home / "aider"
    files.append(xdg_aider_dir / default_file)

    if default_file.startswith("."):
        files.append(xdg_aider_dir / default_file[1:])

    if git_root
        files.append(Path(git_root) / default_file)  # git root

    files.append(default_file)

    if command_line_file:
        files.append(command_line_file)

    resolved_files = []

    for fn in files:
        try:
            resolved_files.append(Path(fn).resolve())
        except OSError:
            pass

    files = resolved_files
    files.reverse()
    uniq = []

    for fn in files:
        if fn not in uniq:
            uniq.append(fn)

    uniq.reverse()
    files = uniq
    files = list(map(str, files))
    files = list(dict.fromkeys(files))

    return files

---

• Thought: 2.1s

The user wants me to refactor a Python function to use fewer operations and be easier to understand. Let me analyze the current code:

1. Builds a list of file paths to search
2. Resolves them to absolute paths
3. Reverses, deduplicates, reverses back
4. Converts to strings
5. Deduplicates again with dict.fromkeys

The second deduplication with dict.fromkeys is redundant since the earlier logic already deduplicates. The reverse-uniq-reverse pattern is a way to preserve last-wins deduplication while keeping first occurrence order.

Let me simplify this.

-> Read .

• Thought: 382ms

The user wants me to refactor the Python function. Let me write the refactored version directly.

def generate_search_path_list(default_file, git_root, command_line_file):
    files = []

    # 1. Home directory
    files.append(Path.home() / default_file)

    # 2. XDG config directory
    xdg = Path(os.environ.get("XDG_CONFIG_HOME") or Path.home() / ".config")
    xdg_aider = xdg / "aider"
    files.append(xdg_aider / default_file)
    if default_file.startswith("."):
        files.append(xdg_aider / default_file[1:])

    # 3. Git root, current directory, command line
    if git_root:
        files.append(Path(git_root) / default_file)
    files.append(default_file)
    if command_line_file:
        files.append(command_line_file)

    # Resolve, deduplicate (last-wins), convert to strings
    seen = set()
    resolved = []
    for f in files:
        try:
            r = Path(f).resolve()
            if r not in seen:
                seen.add(r)
                resolved.append(r)
        except OSError:
            pass

    return [str(f) for f in resolved]

Key changes:

• Eliminated the reverse/uniq/reverse dance — the original reversed the list, removed duplicates (keeping first occurrence = originally last), then reversed back. That's "last-wins" dedup. The new approach iterates forward and skips already-seen paths, which is simpler and does the same thing.
• Removed redundant dict.fromkeys — the seen set already handles deduplication, making the second pass unnecessary.
• Consolidated XDG logic — replaced the if/else block with an or expression.
• Single comprehension for string conversion — replaced list(map(str, files)) with a list comprehension.

Build · Qwen3.6 35B-A3B · 20.0s