Which Ollama Cloud Model is Best? Duck Programmer Debugging at 3AM SVG Comparison (13 Models)

After testing LLMs on ducks, vehicles, and nature scenes, we wanted to know: can today’s top models draw developer culture? This time we asked 13 Ollama cloud models to draw a duck programmer debugging code at 3am with coffee – a relatable dev meme that tests scene composition, screens with code, lighting, and character expression.

The prompt was: Make an svg image about a duck programmer debugging code at 3am with coffee

This is the fifth in our SVG benchmark series. See also: duck on a bicycle, duck with a parachute, duck driving a jeep, and cherry blossom trees.

Why a programmer duck? Unlike previous prompts, this scene combines multiple hard problems for SVG generation: (1) a character with expression (tired eyes, sweat drop), (2) a screen with rendered code/text, (3) indoor lighting with glow effects, (4) scene props (laptop, coffee mug, papers, pizza box), and (5) a relatable narrative moment. A model that draws a great duck jeep may struggle here, and vice versa – which is exactly why we run multiple prompts.

The goal is not to declare a winner – it is to give you the data so you can pick the best model for your own use case. We show you the SVG, the stats, and a short analysis for each. You decide.

How to Choose the Best Ollama Model for Developer/Scene SVGs

Indoor developer-scene prompts reward different things than outdoor nature prompts. Here are the criteria to use:

• Scene composition: Does the SVG have a desk, screen, character, and props arranged in a believable layout? Or is it a jumble of shapes?
• Code on screen: Look for actual rendered text (<text> elements with monospace font), not just colored rectangles pretending to be code.
• Lighting and atmosphere: 3am debugging implies a dark room with screen glow. Does the model use gradients, glows, or filters to convey this?
• Character expression: Is the duck tired, stressed, or focused? Expression requires eyes, eyebrows, sweat drops, or posture. Models that only draw a generic duck miss the prompt’s emotional cue.
• Props: Coffee, laptop, papers, and a clock showing 3:00 are the props the prompt implies. More props = better prompt adherence.
• SVG code quality: Does it use <defs>, <use>, gradients, and clean structure? Better code is easier to tweak (e.g., to recolor or animate).

How It Works

The script discovers all cloud-hosted models via the Ollama API (/api/tags), pulls each model, then sends the identical prompt through the OpenAI-compatible endpoint (http://localhost:11434/v1/chat/completions). Each model’s response is parsed for an <svg>...</svg> block, and the extracted SVG is saved for rendering with zero post-processing (other than adding width="100%" height="auto" for responsive embedding).

Cloud models are identified by the remote_host field in the API response – these models are hosted on Ollama Cloud rather than running locally. This means even very large models (671B parameters) can be queried instantly without local GPU resources.

Summary Table: Compare All 13 Models at a Glance

Use this table to quickly compare models on the metrics that matter. The verdict column is a one-line summary to help you shortlist – but read the per-model sections below for the full picture before you decide.

13 out of 17 active models produced a valid SVG. The 4 retired models returned HTTP 410 Gone (removed from Ollama Cloud on 2026-07-15).

Quick Recommendation by Use Case

If you just want a shortcut, here is which model to pick based on what you care about:

• You want the most detailed programmer scene SVG: pick models labeled “Very high” complexity in the table above
• You want the fastest response: look at the per-model sections below for the elapsed time
• You want the cleanest, most reusable SVG code: pick models that use <defs>, <use>, and transforms (see raw source below each SVG)
• You want a small, efficient SVG for web embedding: pick models with “Compact” verdict
• You want a balance of detail and speed: pick models labeled “Balanced” or “Detailed”
• You want to compare within a model family: pick deepseek-v4-pro vs deepseek-v4-flash, or glm-5.1 vs glm-5.2, or minimax-m2.7 vs minimax-m3

Now read on for the full per-model breakdown and judge for yourself.

1. deepseek-v4-flash_cloud

SVG size: 14873 characters
Complexity: Very high
Shape elements: 126
Distinct colors: 32
Raw response: 15429 characters
Generation time: 39.6s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With over 14,873 characters of SVG markup, this is one of the most detailed outputs in the comparison. The model invested significant effort in rendering scene props, screen code, lighting, and character expression.

2. deepseek-v4-pro_cloud

SVG size: 9197 characters
Complexity: Very high
Shape elements: 72
Distinct colors: 14
Raw response: 9658 characters
Generation time: 53.0s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With over 9,197 characters of SVG markup, this is one of the most detailed outputs in the comparison. The model invested significant effort in rendering scene props, screen code, lighting, and character expression.

3. gemma4_31b-cloud

SVG size: 3056 characters
Complexity: High
Shape elements: 31
Distinct colors: 20
Raw response: 3865 characters
Generation time: 29.7s

Analysis

Notable SVG techniques used:

• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 3,056 characters of SVG markup, this is a detailed output that balances richness with readability.

4. gemma4_cloud

SVG size: 3162 characters
Complexity: Medium
Shape elements: 28
Distinct colors: 16
Raw response: 3943 characters
Generation time: 16.9s

Analysis

Notable SVG techniques used:

• Includes animation elements – the model attempted motion (e.g., steam, blinking)
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 3,162 characters of SVG markup, this is a balanced output – enough detail to convey the scene without being overwhelming.

5. glm-5.1_cloud

SVG size: 30938 characters
Complexity: Very high
Shape elements: 194
Distinct colors: 79
Raw response: 36377 characters
Generation time: 95.9s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With over 30,938 characters of SVG markup, this is one of the most detailed outputs in the comparison. The model invested significant effort in rendering scene props, screen code, lighting, and character expression.

6. glm-5.2_cloud

SVG size: 10821 characters
Complexity: Very high
Shape elements: 89
Distinct colors: 27
Raw response: 10878 characters
Generation time: 77.2s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With over 10,821 characters of SVG markup, this is one of the most detailed outputs in the comparison. The model invested significant effort in rendering scene props, screen code, lighting, and character expression.

7. gpt-oss_120b-cloud

SVG size: 3090 characters
Complexity: Medium
Shape elements: 21
Distinct colors: 15
Raw response: 3951 characters
Generation time: 19.8s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 3,090 characters of SVG markup, this is a balanced output – enough detail to convey the scene without being overwhelming.

8. kimi-k2.6_cloud

SVG size: 6269 characters
Complexity: High
Shape elements: 31
Distinct colors: 17
Raw response: 12782 characters
Generation time: 39.4s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 6,269 characters of SVG markup, this is a detailed output that balances richness with readability.

9. minimax-m2.7_cloud

SVG size: 5324 characters
Complexity: High
Shape elements: 43
Distinct colors: 25
Raw response: 5721 characters
Generation time: 90.2s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 5,324 characters of SVG markup, this is a detailed output that balances richness with readability.

10. minimax-m3_cloud

SVG size: 11304 characters
Complexity: Very high
Shape elements: 82
Distinct colors: 41
Raw response: 12708 characters
Generation time: 90.1s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Includes animation elements – the model attempted motion (e.g., steam, blinking)
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With over 11,304 characters of SVG markup, this is one of the most detailed outputs in the comparison. The model invested significant effort in rendering scene props, screen code, lighting, and character expression.

11. nemotron-3-super_cloud

SVG size: 3664 characters
Complexity: High
Shape elements: 32
Distinct colors: 11
Raw response: 4201 characters
Generation time: 15.3s

Analysis

Notable SVG techniques used:

• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 3,664 characters of SVG markup, this is a detailed output that balances richness with readability.

12. nemotron-3-ultra_cloud

SVG size: 19457 characters
Complexity: Very high
Shape elements: 93
Distinct colors: 39
Raw response: 21303 characters
Generation time: 77.8s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Uses <use> references to reuse defined elements – ideal for repeating UI elements
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Includes animation elements – the model attempted motion (e.g., steam, blinking)
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With over 19,457 characters of SVG markup, this is one of the most detailed outputs in the comparison. The model invested significant effort in rendering scene props, screen code, lighting, and character expression.

13. qwen3.5_397b-cloud

SVG size: 5746 characters
Complexity: High
Shape elements: 54
Distinct colors: 17
Raw response: 5848 characters
Generation time: 57.1s

Analysis

Notable SVG techniques used:

• Uses <defs> blocks for reusable components (a sign of well-structured, editable SVG)
• Includes gradient fills for richer visual depth (great for screen glows and dark rooms)
• Applies SVG filters (e.g., drop shadows, blurs) for atmospheric effects
• Uses transforms (translate, rotate, scale) for positioning props and characters
• Renders actual text on screen (code, labels, clock display)
• Contains XML comments, showing the model’s internal documentation of its work

Concept adherence:

• Duck character is present – the model understood the subject
• Laptop/screen elements are present – the model understood the coding setup
• Coffee/mug elements are present – the model captured the props
• Time indicator (3:00) is present – the model captured the time cue

With 5,746 characters of SVG markup, this is a detailed output that balances richness with readability.

How to Pick the Best Model: A Decision Guide

Now that you have seen all 13 programmer SVGs, here is a structured way to decide which Ollama cloud model is best for your SVG generation needs:

Step 1: Define your priority

• Visual quality first: Scroll back through the SVGs above and pick the one that looks best to your eye. For developer scenes, trust your eye – the shape and color counts are useful, but a model with 30 shapes and a great palette can beat one with 100 shapes and muddy colors.
• Code quality first: Open the raw SVG source for each model (use the disclosure toggles) and look for <defs>, <use>, gradients, and clean indentation. Models that produce structured code are easier to recolor and reuse.
• Speed first: If you are building a real-time app, prioritize the models that responded in under 30 seconds (see the per-model sections for elapsed times).
• File size first: For web embedding, smaller is better. Look at the SVG size column in the summary table.

Step 2: Cross-check across prompts

A model that does well on the programmer duck might fail on a nature prompt. Check our other benchmarks:

• Duck on a bicycle – character + vehicle
• Duck with a parachute – dynamic action scene
• Duck driving a jeep – vehicle with multiple parts
• Cherry blossom trees – nature / scenery with no central character
• This post (programmer duck) – indoor scene with screen + lighting + props

A model that consistently produces good results across all five prompts is a safer pick than one that only shines on a single type of scene.

Step 3: Test with your own prompt

Every model has strengths and weaknesses. The only way to know for sure which model is best for your specific use case is to test it with your own prompt. The Ollama Cloud API is OpenAI-compatible, so you can use any standard client:

from openai import OpenAI
client = OpenAI(base_url="http://localhost:11434/v1", api_key="ollama")
resp = client.chat.completions.create(
    model="glm-5.1:cloud",  # change this to test different models
    messages=[{"role": "user", "content": "Make an svg image of <your prompt>"}],
)
print(resp.choices[0].message.content)

Why This Benchmark Matters: Indoor Scene vs Outdoor Scene Prompts

Most LLM SVG benchmarks only test one type of prompt. We deliberately run five different scene types because models specialize:

• Character + vehicle prompts (the duck bicycle/jeep series) reward models that understand anatomy, proportions, and mechanical parts. Models like deepseek-v4-pro and kimi-k2.6 tend to do well here.
• Dynamic action prompts (the duck parachute) reward models that understand motion, perspective, and dynamic composition.
• Nature prompts (cherry blossom) reward models that understand organic shapes, palettes, and repetition. Models like glm-5.1 and nemotron-3-ultra tend to do well here.
• Indoor scene prompts (this programmer duck post) reward models that understand lighting, screen text, props, and narrative. Models that can render readable text on a screen and convey a mood (tired, focused) are rare.

If you are picking a model for a specific project, look at the benchmark closest to your use case. If you want a general-purpose model, pick one that does okay across all five rather than one that aces one and fails the rest.

Conclusion: You Decide the Winner

This comparison shows that 13 out of 17 active Ollama cloud models can generate valid SVG artwork from a developer-culture prompt about a duck programmer debugging code at 3am. The results vary dramatically in complexity, style, and technique – and there is no single “best” model.

Our takeaways after running five SVG benchmarks (bicycle, parachute, jeep, blossom, programmer):

• glm-5.1:cloud and nemotron-3-ultra:cloud consistently produce the longest, most detailed SVGs across all prompt types. Best when you want maximum visual richness.
• deepseek-v4-pro:cloud and deepseek-v4-flash:cloud consistently produce well-structured, technically advanced SVGs with <defs>, <use>, and transforms. A strong default choice for code quality and editability.
• gpt-oss:120b-cloud and gemma4:31b-cloud are consistently among the fastest and produce compact SVGs. Best for speed-sensitive applications.
• kimi-k2.6:cloud output size varies wildly by prompt – worth testing on your specific prompt.
• glm-5.2:cloud and minimax-m3:cloud offer a reliable balance of detail, speed, and code quality across all five prompts.

But the real verdict is yours. Scroll back through the SVGs, compare them visually, check the raw code, and pick the model that best fits your needs. Every model in this comparison is available right now on Ollama Cloud – so you can reproduce these results in minutes.

Links

• Previous: Duck Driving a Bicycle Comparison
• Previous: Duck Jumping From a Plane Comparison
• Previous: Duck Driving a Jeep Comparison
• Previous: Cherry Blossom Trees Comparison
• Ollama Official Website
• Ollama Cloud Documentation
• SVG Specification (MDN)
• OpenAI API Reference (used by Ollama)

Enjoyed this post? Never miss out on future posts by following us