[GH-ISSUE #14421] qwen3.5:35b Looping Issue #55874

New Issue

GiteaMirror · 2026-04-29T09:51:00-05:00

GiteaMirror commented

2026-04-29 09:51:00 -05:00

Originally created by @PetrRichter on GitHub (Feb 25, 2026).
Original GitHub issue: https://github.com/ollama/ollama/issues/14421

What is the issue?

qwen3.5:35b gets stuck in endless loops.
Ollama Version 0.17.1-rc1

Relevant log output

No insightful logs just multiple GET and POST even though it was just one chat input (looping by itself)

OS

Windows

GPU

AMD

CPU

AMD

Ollama version

0.17.1-rc1

Originally created by @PetrRichter on GitHub (Feb 25, 2026). Original GitHub issue: https://github.com/ollama/ollama/issues/14421 ### What is the issue? qwen3.5:35b gets stuck in endless loops. Ollama Version 0.17.1-rc1 ### Relevant log output ```shell No insightful logs just multiple GET and POST even though it was just one chat input (looping by itself) ``` ### OS Windows ### GPU AMD ### CPU AMD ### Ollama version 0.17.1-rc1

GiteaMirror added the bug label 2026-04-29 09:51:00 -05:00

GiteaMirror commented

2026-04-29 09:51:03 -05:00

@xmddmx commented on GitHub (Feb 26, 2026):

Similar for me.

This prompt (on macOS Ollama .17.1-rc1, M4 Pro MacBook with 48GB RAM, ollama context set at 32K ) ends up looping,

"Puzzle game: there are 16 words, grouped into 4 categories, which can include semantic, phonetic, or more tricky (such as adding or removing a letter or word). The 4 categories vary in difficulty, from obvious to obscure. Please tell me the 4 words in each category, and define the category, and list the categories in order from easiest to hardest. Here are the 16 words: calliope superiority ringmaster atlas oedipus buzzard echo electra trace dialect inferiority dictionary thesaurus reminder encyclopedia vestige"

(this is a NYT Connections puzzle from recently)

It thinks for about 615 seconds, then gets stuck.

The final loop is:

Is it "Words that contain the word 'Ring'"?

[etc.]

@xmddmx commented on GitHub (Feb 26, 2026): Similar for me. This prompt (on macOS Ollama .17.1-rc1, M4 Pro MacBook with 48GB RAM, ollama context set at 32K ) ends up looping, "Puzzle game: there are 16 words, grouped into 4 categories, which can include semantic, phonetic, or more tricky (such as adding or removing a letter or word). The 4 categories vary in difficulty, from obvious to obscure. Please tell me the 4 words in each category, and define the category, and list the categories in order from easiest to hardest. Here are the 16 words: calliope superiority ringmaster atlas oedipus buzzard echo electra trace dialect inferiority dictionary thesaurus reminder encyclopedia vestige" (this is a NYT Connections puzzle from recently) It thinks for about 615 seconds, then gets stuck. The final loop is: Is it "Words that contain the word 'Ring'"? Is it "Words that contain the word 'Ring'"? Is it "Words that contain the word 'Ring'"? Is it "Words that contain the word 'Ring'"? Is it "Words that contain the word 'Ring'"? [etc.]

GiteaMirror commented

2026-04-29 09:51:04 -05:00

@xmddmx commented on GitHub (Feb 27, 2026):

FYI, I updated to 0.17.2 and I'm no longer seeing this looping behavior with the latest qwen3.5:35b

@xmddmx commented on GitHub (Feb 27, 2026): FYI, I updated to 0.17.2 and I'm no longer seeing this looping behavior with the latest qwen3.5:35b

GiteaMirror commented

2026-04-29 09:51:05 -05:00

@without-ordinary commented on GitHub (Feb 27, 2026):

I'm running 0.17.4 and qwen3.5:122b-a10b, when I don't get https://github.com/ollama/ollama/issues/14444 while loading, I'll get this looping issue on the first response when using ollama cli chat but not when using openwebui.

Example:

>>> This is a test, reply "hello" 
Thinking...
Thinking Process:

1.  **Analyze the Request:**
    *   Input: "This is a test, reply "hello""
    *   Intent: The user is testing the system's response capability.
    *   Constraint: The user explicitly asks me to reply "hello".

2.  **Determine the appropriate response:**
    *   The instruction is clear and simple.
    *   I need to output the word "hello" as requested.
    *   I should avoid adding unnecessary fluff unless it helps clarify, but sticking to the instruction is usually best for tests.

3.  **Draft the response:**
    *   Option 1: hello
    *   Option 2: Hello
    *   Option 3: "hello"
    *   Selection: Option 2 (Hello) is the most natural capitalization, but the user wrote "hello" in lowercase. However, standard English capitalization is usually preferred unless specified otherwise. Let's look at 
the instruction: reply "hello". Usually, this means the content should be hello. I will reply with "Hello" to be polite and standard, or "hello" to be exact. Given it's a test, exactness might be appreciated, but 
"Hello" is safer for general interaction. Actually, looking at common practices, just writing the word is key. I'll write "hello" to match the prompt exactly, or "Hello" for correctness. Let's go with "Hello" as it's 
the standard greeting. Wait, if I want to be precise to the instruction "reply 'hello'", I should output hello. But often users accept "Hello". I will output "hello" to be strictly compliant.
    *   Re-evaluation: The prompt says reply "hello". I will output exactly that.

4.  **Final Decision:**
    *   Output: hello
    *   Wait, adding a little context might be nice but the instruction is a test. Keep it simple.
    *   Actually, capitalizing the first letter is standard for a sentence. "Hello" looks better. But if it's a string match test... Let's just say "hello".
    *   Okay, I'll just say "hello".
    *   Wait, I am an AI assistant. I should be helpful. A simple "hello" is best.
    *   Let's check the instruction again: `reply "hello"`.
    *   I will output: hello
    *   Actually, I'll capitalize it because it's the start of a message. "Hello". No, let's stick to the prompt's casing to show I followed instructions precisely. "hello".
    *   Decision: "hello" (lowercase) might look like I'm being lazy. "Hello" is standard. I'll use "Hello".
    *   Wait, no. If a user says "say hello", you say "Hello". If they say "reply 'hello'", they might be testing string matching. I'll output "hello".
    *   Actually, most likely they just want to see if I respond. I'll output "Hello". It's more natural.
    *   Okay, final decision: "Hello". (Capitalized for correctness).
    *   Wait, looking at the prompt again: `reply "hello"`. I will output exactly `hello`.
    *   Okay, I'll just output the word.
    *   Wait, I should not overthink. Just reply.
    *   Response: hello

5.  **Final Polish:**
    *   Keep it concise.
    *   "hello"
    *   (Self-Correction): Since I'm an AI, standard greeting is "Hello". I'll use "Hello".
    *   Wait, if I'm being tested, maybe they want exact string. I'll use "hello".
    *   Okay, I'll go with "hello".
    *   Actually, I'll add a period? No, the prompt didn't ask for one.
    *   Okay, just "hello".
    *   Wait, I should check if there are any safety guidelines. No.
    *   Okay, proceeding.
    *   Wait, one more thought. If I write "Hello", it's still replying "hello". I'll write "Hello".
    *   Okay, I'll write "Hello".
    *   Wait, the prompt says reply "hello". I will write hello.
    *   Okay, final final decision: hello.
    *   Wait, I'll capitalize it. It's a start of a sentence. Hello.
    *   Okay, I'm overthinking. Just output the text.
    *   "hello"
    *   Okay, I'll output: hello
    *   Wait, I'll output: Hello
    *   Okay, I'll output: hello
    *   (Decided): I will output "hello" exactly as requested in quotes to show compliance.
    *   Wait, no, I should not include the quotes unless asked to repeat the quotes. Just the word.
    *   Okay: hello
    *   Wait, I'll capitalize. Hello.
    *   Okay, I'll stop wavering. I'll output "Hello".
    *   Wait, the prompt is `reply "hello"`.
    *   Okay, I'll output: hello
    *   Wait, I'll output: Hello
    *   Okay, I'll output: hello
    *   (Final Final Decision): I will output "hello". It matches the prompt exactly.
    *   Wait, I'll output "Hello". It's more professional.
    *   Okay, I'll output "hello".
    *   Wait, I'll output "Hello".
    *   Okay, I'll output "hello".
    *   (Stop loop). I'll output "hello".
    *   Wait, I'll output "Hello".
    *   Okay, I'll output "hello".
    *   (Reasoning): The user asked to reply "hello". I will do exactly that.
    *   Output: hello
    *   Wait, I'll capitalize. Hello.
    *   Okay, I'll output: Hello
    *   (Final Decision): Hello.
    *   Wait, I'll just output hello.
    *   Okay, I'll output: hello
    *   (Wait, I need to stop this loop). I will output: hello
    *   (Wait, I'll output: Hello)
    *   (Okay, I'll output: hello)
    *   (Okay, I'll output: Hello)
    *   (Okay, I'll output: hello)
    *   Okay, I'll output: Hello. It's a greeting.
    *   Wait, the instruction is specific. "hello".
    *   Okay, I'll output: hello
    *   (End of thought process)
    *   Wait, I'll just output hello.
    *   Okay.
    *   Wait, I'll output: hello
    *   (Okay, final answer)
    *   hello
    *   Wait, I'll capitalize.
    *   Hello
    *   Okay, I'll output: hello
    *   (Stop)
    *   Okay, I'll output: hello
    *   (Wait, I'll output: Hello)
    *   (Okay, I'll output: hello)
    *   (Okay, I'll output: Hello)
    *   (Okay, I'll output: hello)
    *   (Okay, I'll output: Hello)
    *   (Okay, I'll output: hello)
[...]

It repeats the last output, switching between h and H each time. (I've removed the excess blank lines from the output to save space.)

@without-ordinary commented on GitHub (Feb 27, 2026): I'm running `0.17.4` and `qwen3.5:122b-a10b`, when I don't get https://github.com/ollama/ollama/issues/14444 while loading, I'll get this looping issue on the first response when using ollama cli chat but not when using openwebui. Example: ``` >>> This is a test, reply "hello" Thinking... Thinking Process: 1. **Analyze the Request:** * Input: "This is a test, reply "hello"" * Intent: The user is testing the system's response capability. * Constraint: The user explicitly asks me to reply "hello". 2. **Determine the appropriate response:** * The instruction is clear and simple. * I need to output the word "hello" as requested. * I should avoid adding unnecessary fluff unless it helps clarify, but sticking to the instruction is usually best for tests. 3. **Draft the response:** * Option 1: hello * Option 2: Hello * Option 3: "hello" * Selection: Option 2 (Hello) is the most natural capitalization, but the user wrote "hello" in lowercase. However, standard English capitalization is usually preferred unless specified otherwise. Let's look at the instruction: reply "hello". Usually, this means the content should be hello. I will reply with "Hello" to be polite and standard, or "hello" to be exact. Given it's a test, exactness might be appreciated, but "Hello" is safer for general interaction. Actually, looking at common practices, just writing the word is key. I'll write "hello" to match the prompt exactly, or "Hello" for correctness. Let's go with "Hello" as it's the standard greeting. Wait, if I want to be precise to the instruction "reply 'hello'", I should output hello. But often users accept "Hello". I will output "hello" to be strictly compliant. * Re-evaluation: The prompt says reply "hello". I will output exactly that. 4. **Final Decision:** * Output: hello * Wait, adding a little context might be nice but the instruction is a test. Keep it simple. * Actually, capitalizing the first letter is standard for a sentence. "Hello" looks better. But if it's a string match test... Let's just say "hello". * Okay, I'll just say "hello". * Wait, I am an AI assistant. I should be helpful. A simple "hello" is best. * Let's check the instruction again: `reply "hello"`. * I will output: hello * Actually, I'll capitalize it because it's the start of a message. "Hello". No, let's stick to the prompt's casing to show I followed instructions precisely. "hello". * Decision: "hello" (lowercase) might look like I'm being lazy. "Hello" is standard. I'll use "Hello". * Wait, no. If a user says "say hello", you say "Hello". If they say "reply 'hello'", they might be testing string matching. I'll output "hello". * Actually, most likely they just want to see if I respond. I'll output "Hello". It's more natural. * Okay, final decision: "Hello". (Capitalized for correctness). * Wait, looking at the prompt again: `reply "hello"`. I will output exactly `hello`. * Okay, I'll just output the word. * Wait, I should not overthink. Just reply. * Response: hello 5. **Final Polish:** * Keep it concise. * "hello" * (Self-Correction): Since I'm an AI, standard greeting is "Hello". I'll use "Hello". * Wait, if I'm being tested, maybe they want exact string. I'll use "hello". * Okay, I'll go with "hello". * Actually, I'll add a period? No, the prompt didn't ask for one. * Okay, just "hello". * Wait, I should check if there are any safety guidelines. No. * Okay, proceeding. * Wait, one more thought. If I write "Hello", it's still replying "hello". I'll write "Hello". * Okay, I'll write "Hello". * Wait, the prompt says reply "hello". I will write hello. * Okay, final final decision: hello. * Wait, I'll capitalize it. It's a start of a sentence. Hello. * Okay, I'm overthinking. Just output the text. * "hello" * Okay, I'll output: hello * Wait, I'll output: Hello * Okay, I'll output: hello * (Decided): I will output "hello" exactly as requested in quotes to show compliance. * Wait, no, I should not include the quotes unless asked to repeat the quotes. Just the word. * Okay: hello * Wait, I'll capitalize. Hello. * Okay, I'll stop wavering. I'll output "Hello". * Wait, the prompt is `reply "hello"`. * Okay, I'll output: hello * Wait, I'll output: Hello * Okay, I'll output: hello * (Final Final Decision): I will output "hello". It matches the prompt exactly. * Wait, I'll output "Hello". It's more professional. * Okay, I'll output "hello". * Wait, I'll output "Hello". * Okay, I'll output "hello". * (Stop loop). I'll output "hello". * Wait, I'll output "Hello". * Okay, I'll output "hello". * (Reasoning): The user asked to reply "hello". I will do exactly that. * Output: hello * Wait, I'll capitalize. Hello. * Okay, I'll output: Hello * (Final Decision): Hello. * Wait, I'll just output hello. * Okay, I'll output: hello * (Wait, I need to stop this loop). I will output: hello * (Wait, I'll output: Hello) * (Okay, I'll output: hello) * (Okay, I'll output: Hello) * (Okay, I'll output: hello) * Okay, I'll output: Hello. It's a greeting. * Wait, the instruction is specific. "hello". * Okay, I'll output: hello * (End of thought process) * Wait, I'll just output hello. * Okay. * Wait, I'll output: hello * (Okay, final answer) * hello * Wait, I'll capitalize. * Hello * Okay, I'll output: hello * (Stop) * Okay, I'll output: hello * (Wait, I'll output: Hello) * (Okay, I'll output: hello) * (Okay, I'll output: Hello) * (Okay, I'll output: hello) * (Okay, I'll output: Hello) * (Okay, I'll output: hello) [...] ``` It repeats the last output, switching between `h` and `H` each time. (I've removed the excess blank lines from the output to save space.)

GiteaMirror commented

2026-04-29 09:51:05 -05:00

@sqblg commented on GitHub (Feb 27, 2026):

This looping behavior is a classic 'reasoning cap' issue where smaller local models get lost in complex or repetitive instructions.

I've been solving this with a hybrid approach using ClawRouter (https://github.com/BlockRunAI/ClawRouter). It sits in front of Ollama and scores each prompt across 15 dimensions. If a task looks like it might trigger a loop or requires higher 'IQ', it can automatically route that specific call to a cloud flagship (like Claude 3.5), while keeping everything else local and cheap. It’s been a life-saver for keeping my Qwen/Llama agent workflows stable without blowing my entire API budget.

@sqblg commented on GitHub (Feb 27, 2026): This looping behavior is a classic 'reasoning cap' issue where smaller local models get lost in complex or repetitive instructions. I've been solving this with a hybrid approach using **ClawRouter** (https://github.com/BlockRunAI/ClawRouter). It sits in front of Ollama and scores each prompt across 15 dimensions. If a task looks like it might trigger a loop or requires higher 'IQ', it can automatically route that specific call to a cloud flagship (like Claude 3.5), while keeping everything else local and cheap. It’s been a life-saver for keeping my Qwen/Llama agent workflows stable without blowing my entire API budget.

GiteaMirror commented

2026-04-29 09:51:06 -05:00

@rick-github commented on GitHub (Feb 27, 2026):

Server logs will aid in debugging.

@rick-github commented on GitHub (Feb 27, 2026): [Server logs](https://docs.ollama.com/troubleshooting) will aid in debugging.

GiteaMirror commented

2026-04-29 09:51:06 -05:00

@xmddmx commented on GitHub (Feb 27, 2026):

Could this be "Bug 1" described here? https://github.com/ollama/ollama/issues/14493

The Go runner's sampler has zero implementation of penalty sampling. repeat_penalty, presence_penalty, and frequency_penalty are accepted by the API without error and silently discarded. The model card explicitly recommends presence_penalty=1.5 to prevent repetition loops during thinking

@xmddmx commented on GitHub (Feb 27, 2026): Could this be "Bug 1" described here? https://github.com/ollama/ollama/issues/14493 > The Go runner's sampler has zero implementation of penalty sampling. repeat_penalty, presence_penalty, and frequency_penalty are accepted by the API without error and silently discarded. The model card explicitly recommends presence_penalty=1.5 to prevent repetition loops during thinking

GiteaMirror commented

2026-04-29 09:51:07 -05:00

@javajuice1337 commented on GitHub (Mar 17, 2026):

Please fix this... qwen models have been looping in ollama forever... qwen 3.5 models are doing it too. Thank you.

@javajuice1337 commented on GitHub (Mar 17, 2026): Please fix this... qwen models have been looping in ollama forever... qwen 3.5 models are doing it too. Thank you.

GiteaMirror commented

2026-04-29 09:51:07 -05:00

@rick-github commented on GitHub (Mar 17, 2026):

Server logs will aid in debugging.

@rick-github commented on GitHub (Mar 17, 2026): [Server logs](https://docs.ollama.com/troubleshooting) will aid in debugging.

Sign in to join this conversation.

Branches Tags

main

dhiltgen/ci

dhiltgen/llama-runner

parth-launch-codex-app

hoyyeva/anthropic-local-image-path

hoyyeva/anthropic-reference-images-path

parth-anthropic-reference-images-path

brucemacd/download-before-remove

hoyyeva/editor-config-repair

parth-mlx-decode-checkpoints

hoyyeva/fix-codex-model-metadata-warning

hoyyeva/qwen

parth/hide-claude-desktop-till-release

hoyyeva/opencode-image-modality

parth-add-claude-code-autoinstall

release_v0.22.0

pdevine/manifest-list

codex/fix-codex-model-metadata-warning

pdevine/addressable-manifest

brucemacd/launch-fetch-reccomended

jmorganca/llama-compat

launch-copilot-cli

hoyyeva/opencode-thinking

release_v0.20.7

parth-auto-save-backup

parth-test

jmorganca/gemma4-audio-replacements

fix-manifest-digest-on-pull

hoyyeva/vscode-improve

brucemacd/install-server-wait

parth/update-claude-docs

brucemac/start-ap-install

pdevine/mlx-update

pdevine/qwen35_vision

drifkin/api-show-fallback

mintlify/image-generation-1773352582

hoyyeva/server-context-length-local-config

jmorganca/faster-reptition-penalties

jmorganca/convert-nemotron

parth-pi-thinking

pdevine/sampling-penalties

jmorganca/fix-create-quantization-memory

dongchen/resumable_transfer_fix

pdevine/sampling-cache-error

jessegross/mlx-usage

hoyyeva/openclaw-config

hoyyeva/app-html

pdevine/qwen3next

brucemacd/sign-sh-install

brucemacd/tui-update

brucemacd/usage-api

jmorganca/launch-empty

fix-app-dist-embed

mxyng/mlx-compile

mxyng/mlx-quant

mxyng/mlx-glm4.7

mxyng/mlx

brucemacd/simplify-model-picker

jmorganca/qwen3-concurrent

fix-glm-4.7-flash-mla-config

drifkin/qwen3-coder-opening-tag

brucemacd/usage-cli

fix-cuda12-fattn-shmem

ollama-imagegen-docs

parth/fix-multiline-inputs

brucemacd/config-docs

mxyng/model-files

mxyng/simple-execute

fix-imagegen-ollama-models

mxyng/async-upload

jmorganca/lazy-no-dtype-changes

imagegen-auto-detect-create

parth/decrease-concurrent-download-hf

fix-mlx-quantize-init

jmorganca/x-cleanup

usage

imagegen-readme

jmorganca/glm-image

mlx-gpu-cd

jmorganca/imagegen-modelfile

parth/agent-skills

parth/agent-allowlist

parth/signed-in-offline

parth/agents

parth/fix-context-chopping

improve-cloud-flow

parth/add-models-websearch

parth/prompt-renderer-mcp

jmorganca/native-settings

jmorganca/download-stream-hash

jmorganca/client2-rebased

brucemacd/oai-chat-req-multipart

jessegross/multi_chunk_reserve

grace/additional-omit-empty

grace/mistral-3-large

mxyng/tokenizer2

mxyng/tokenizer

jessegross/flash

hoyyeva/windows-nacked-app

mxyng/cleanup-attention

grace/deepseek-parser

hoyyeva/remember-unsent-prompt

parth/add-lfs-pointer-error-conversion

parth/olmo2-test2

hoyyeva/ollama-launchagent-plist

nicole/olmo-model

parth/olmo-test

mxyng/remove-embedded

parth/render-template

jmorganca/intellect-3

parth/remove-prealloc-linter

jmorganca/cmd-eval

nicole/nomic-embed-text-fix

mxyng/lint-2

hoyyeva/add-gemini-3-pro-preview

hoyyeva/load-model-list

mxyng/expand-path

mxyng/environ-2

hoyyeva/deeplink-json-encoding

parth/improve-tool-calling-tests

hoyyeva/conversation

hoyyeva/assistant-edit-response

hoyyeva/thinking

origin/brucemacd/invalid-char-i-err

parth/improve-tool-calling

jmorganca/required-omitempty

grace/qwen3-vl-tests

mxyng/iter-client

parth/docs-readme

nicole/embed-test

pdevine/integration-benchstat

parth/remove-generate-cmd

parth/add-toolcall-id

mxyng/server-tests

jmorganca/glm-4.6

jmorganca/gin-h-compat

drifkin/stable-tool-args

pdevine/qwen3-more-thinking

parth/add-websearch-client

nicole/websearch_local

jmorganca/qwen3-coder-updates

grace/deepseek-v3-migration-tests

mxyng/fix-create

jmorganca/cloud-errors

pdevine/parser-tidy

revert-12233-parth/simplify-entrypoints-runner

parth/enable-so-gpt-oss

brucemacd/qwen3vl

jmorganca/readme-simplify

parth/gpt-oss-structured-outputs

revert-12039-jmorganca/tools-braces

mxyng/embeddings

mxyng/gguf

mxyng/benchmark

mxyng/types-null

parth/move-parsing

mxyng/gemma2

jmorganca/docs

mxyng/16-bit

mxyng/create-stdin

pdevine/authorizedkeys

mxyng/quant

parth/opt-in-error-context-window

brucemacd/cache-models

brucemacd/runner-completion

jmorganca/llama-update-6

brucemacd/benchmark-list

brucemacd/partial-read-caps

parth/deepseek-r1-tools

mxyng/omit-array

parth/tool-prefix-temp

brucemacd/runner-test

jmorganca/qwen25vl

brucemacd/model-forward-test-ext

parth/python-function-parsing

jmorganca/cuda-compression-none

drifkin/num-parallel

drifkin/chat-truncation-fix

jmorganca/sync

parth/python-tools-calling

drifkin/array-head-count

brucemacd/create-no-loop

parth/server-enable-content-stream-with-tools

qwen25omni

mxyng/v3

brucemacd/ropeconfig

jmorganca/silence-tokenizer

parth/sample-so-test

parth/sampling-structured-outputs

brucemacd/doc-go-engine

parth/constrained-sampling-json

jmorganca/mistral-wip

brucemacd/mistral-small-convert

parth/sample-unmarshal-json-for-params

brucemacd/jomorganca/mistral

pdevine/bfloat16

jmorganca/mistral

brucemacd/mistral

pdevine/logging

parth/sample-correctness-fix

parth/sample-fix-sorting

jmorgan/sample-fix-sorting-extras

jmorganca/temp-0-images

brucemacd/parallel-embed-models

brucemacd/shim-grammar

jmorganca/fix-gguf-error

bmizerany/nameswork

jmorganca/faster-releases

bmizerany/validatenames

brucemacd/err-no-vocab

brucemacd/rope-config

brucemacd/err-hint

brucemacd/qwen2_5

brucemacd/logprobs

brucemacd/new_runner_graph_bench

progress-flicker

brucemacd/forward-test

brucemacd/go_qwen2

pdevine/gemma2

jmorganca/add-missing-symlink-eval

mxyng/next-debug

parth/set-context-size-openai

brucemacd/next-bpe-bench

brucemacd/next-bpe-test

brucemacd/new_runner_e2e

brucemacd/new_runner_qwen2

pdevine/convert-cohere2

brucemacd/convert-cli

parth/log-probs

mxyng/next-mlx

mxyng/cmd-history

parth/templating

parth/tokenize-detokenize

brucemacd/check-key-register

bmizerany/grammar

jmorganca/vendor-081b29bd

mxyng/func-checks

jmorganca/fix-null-format

parth/fix-default-to-warn-json

jmorganca/qwen2vl

jmorganca/no-concat

parth/cmd-cleanup-SO

brucemacd/check-key-register-structured-err

parth/openai-stream-usage

parth/fix-referencing-so

stream-tools-stop

jmorganca/degin-1

brucemacd/install-path-clean

brucemacd/push-name-validation

brucemacd/browser-key-register

jmorganca/openai-fix-first-message

jmorganca/fix-proxy

jessegross/sample

parth/disallow-streaming-tools

dhiltgen/remove_submodule

jmorganca/ga

jmorganca/mllama

pdevine/newlines

pdevine/geems-2b

jmorganca/llama-bump

mxyng/modelname-7

mxyng/gin-slog

mxyng/modelname-6

jyan/convert-prog

jyan/quant5

paligemma-support

pdevine/import-docs

jmorganca/openai-context

jyan/paligemma

jyan/p2

jyan/palitest

bmizerany/embedspeedup

jmorganca/llama-vit

brucemacd/allow-ollama

royh/ep-methods

royh/whisper

mxyng/api-models

mxyng/fix-memory

jyan/q4_4/8

jyan/ollama-v

royh/stream-tools

roy-embed-parallel

bmizerany/hrm

revert-5963-revert-5924-mxyng/llama3.1-rope

royh/embed-viz

jyan/local2

jyan/auth

jyan/local

jyan/parse-temp

jmorganca/template-mistral

jyan/reord-g

royh-openai-suffixdocs

royh-imgembed

royh-embed-parallel

jyan/quant4

royh-precision

jyan/progress

pdevine/fix-template

jyan/quant3

pdevine/ggla

mxyng/update-registry-domain

jmorganca/ggml-static

mxyng/create-context

jyan/v0.146

mxyng/layers-from-files

build_dist

bmizerany/noseek

royh-ls

royh-name

timeout

mxyng/server-timestamp

bmizerany/nosillyggufslurps

royh-params

jmorganca/llama-cpp-7c26775

royh-openai-delete

royh-show-rigid

jmorganca/enable-fa

jmorganca/no-error-template

jyan/format

royh-testdelete

bmizerany/fastverify

language_support

pdevine/ps-glitches

brucemacd/tokenize

bruce/iq-quants

bmizerany/filepathwithcoloninhost

mxyng/split-bin

bmizerany/client-registry

jmorganca/if-none-match

native

jmorganca/native

jmorganca/batch-embeddings

jmorganca/initcmake

jmorganca/mm

pdevine/showggmlinfo

modenameenforcealphanum

bmizerany/modenameenforcealphanum

jmorganca/done-reason

jmorganca/llama-cpp-8960fe8

ollama.com

bmizerany/filepathnobuild

bmizerany/types/model/defaultfix

rmdisplaylong

nogogen

bmizerany/x

modelfile-readme

bmizerany/replacecolon

jmorganca/limit

jmorganca/execstack

jmorganca/replace-assets

mxyng/tune-concurrency

jmorganca/testing

whitespace-detection

jmorganca/options

upgrade-all

scratch

cuda-search

mattw/airenamer

mattw/allmodelsonhuggingface

mattw/quantcontext

mattw/whatneedstorun

brucemacd/llama-mem-calc

mattw/faq-context

mattw/communitylinks

mattw/noprune

mattw/python-functioncalling

rename

mxyng/install

pulse

remove-first

editor

mattw/selfqueryingretrieval

cgo

mattw/howtoquant

api

matt/streamingapi

format-config

mxyng/extra-args

shell

update-nous-hermes

cp-model

upload-progress

fix-unknown-model

fix-model-names

delete-fix

insecure-registry

ls

deletemodels

progressbar

readme-updates

license-layers

skip-list

list-models

modelpath

matt/examplemodelfiles

distribution

go-opts

1 Participants

Notifications

Due Date

No due date set.

Dependencies

No dependencies set.

Reference: github-starred/ollama#55874