Kimi K3 · Coding

Kimi K3 for coding: our test runs

Kimi K3 ran our 5 coding prompts in llmwise, through the same pipeline your messages take. Here's every reply as it came, whether it passed, what it cost and what it counts as on Pro, next to the other models.

Start free See pricing

Based on 5 of our test runs on September 27, 2026, through OpenRouter with the app's own prompt and settings. Updated September 27, 2026.

Short answer

In our test runs on September 27, 2026, Kimi K3 passed 5 of 5 of our coding prompts (both hard ones): tied 1st of 15 models. Each reply counted as 1 message on Pro, where it has 125 a month, and cost $0.0063 to run on average.

Prompt by prompt

Each of the 5 coding prompts, and how Kimi K3's reply did.

Kimi K3 on each coding prompt
Prompt	Result	Cost	Time
Turn a title into a URL slugEveryday	Passed: All 7 tests passed.	$0.0035	2.6 s
Parse a duration like “1h 30m”Everyday	Passed: All 10 tests passed.	$0.0063	7.1 s
Merge overlapping intervalsEveryday	Passed: All 7 tests passed.	$0.0036	2.0 s
Evaluate an arithmetic expression, no evalHard	Passed: All 15 tests passed.	$0.0113	9.9 s
Parse CSV with quoted fieldsHard	Passed: All 8 tests passed.	$0.0069	4.1 s

Every coding reply from Kimi K3

Turn a title into a URL slug
An everyday prompt: “Turn a title into a URL slug”, in full.
Passed: All 7 tests passed.
```
```javascript
function slugify(title) {
  return title
    .normalize("NFD")
    .replace(/[̀-ͯ]/g, "")
    .toLowerCase()
    .replace(/[^a-z0-9]+/g, "-")
    .replace(/^-+|-+$/g, "");
}
```
```
574 tokens in, 97 out (16 of them reasoning) · 2.6 s · $0.0035 · 1 message on Pro · answered by moonshotai/kimi-k3 via Fireworks · September 27, 2026

Parse a duration like “1h 30m”

An everyday prompt: “Parse a duration like “1h 30m””, in full.

Passed: All 10 tests passed.

```javascript
function parseDuration(text) {
  if (typeof text !== "string") return null;
  const match = /^\s*(?:(\d+)h)?\s*(?:(\d+)m)?\s*(?:(\d+)s)?\s*$/.exec(text);
  if (!match) return null;
  const [, h, m, s] = match;
  if (h === undefined && m === undefined && s === undefined) return null;
  return (h ? Number(h) * 3600 : 0) + (m ? Number(m) * 60 : 0) + (s ? Number(s) : 0);
}
```

The regex enforces the `h` → `m` → `s` order with each unit at most once and allows optional whitespace between parts and around the whole string. Inputs like `""`, `"h"`, `"1x"`, or `"5m 1h"` fail the match (or the "at least one part" check) and return `null`.

555 tokens in, 325 out (93 of them reasoning) · 7.1 s · $0.0063 · 1 message on Pro · answered by moonshotai/kimi-k3 via Together · September 27, 2026

Merge overlapping intervals

An everyday prompt: “Merge overlapping intervals”, in full.

Passed: All 7 tests passed.

```javascript
function mergeIntervals(intervals) {
  const sorted = intervals
    .map(([start, end]) => [start, end])
    .sort((a, b) => a[0] - b[0] || a[1] - b[1]);

  const merged = [];
  for (const [start, end] of sorted) {
    const last = merged[merged.length - 1];
    if (last && start <= last[1]) {
      last[1] = Math.max(last[1], end);
    } else {
      merged.push([start, end]);
    }
  }
  return merged;
}
```

536 tokens in, 152 out (4 of them reasoning) · 2.0 s · $0.0036 · 1 message on Pro · answered by moonshotai/kimi-k3 via Together · September 27, 2026

Evaluate an arithmetic expression, no eval

A hard prompt: “Evaluate an arithmetic expression, no eval”, in full.

Passed: All 15 tests passed.

```javascript
function evaluate(expression) {
  if (typeof expression !== "string") {
    throw new Error("Input must be a string");
  }

  let pos = 0;

  function skipSpaces() {
    while (pos < expression.length && expression[pos] === " ") {
      pos++;
    }
  }

  function peek() {
    skipSpaces();
    return pos < expression.length ? expression[pos] : null;
  }

  function parseExpression() {
    let value = parseTerm();
    for (;;) {
      const ch = peek();
      if (ch === "+") {
        pos++;
        value += parseTerm();
      } else if (ch === "-") {
        pos++;
        value -= parseTerm();
      } else {
        return value;
      }
    }
  }

  function parseTerm() {
    let value = parseUnary();
    for (;;) {
      const ch = peek();
      if (ch === "*") {
        pos++;
        value *= parseUnary();
      } else if (ch === "/") {
        pos++;
        value /= parseUnary();
      } else {
        return value;
      }
    }
  }

  function parseUnary() {
    const ch = peek();
    if (ch === "-") {
      pos++;
      return -parseUnary();
    }
    if (ch === "+") {
      pos++;
      return parseUnary();
    }
    return parsePower();
  }

  function parsePower() {
    const base = parsePrimary();
    if (peek() === "^") {
      pos++;
      const exponent = parseUnary(); // right-associative, allows 2^-1
      return Math.pow(base, exponent);
    }
    return base;
  }

  function parsePrimary() {
    const ch = peek();
    if (ch === null) {
      throw new Error("Unexpected end of expression");
    }
    if (ch === "(") {
      pos++;
      const value = parseExpression();
      if (peek() !== ")") {
        throw new Error("Missing closing parenthesis");
      }
      pos++;
      return value;
    }
    return parseNumber();
  }

  function parseNumber() {
    skipSpaces();
    const start = pos;
    let sawDigit = false;
    while (pos < expression.length && expression[pos] >= "0" && expression[pos] <= "9") {
      pos++;
      sawDigit = true;
    }
    if (pos < expression.length && expression[pos] === ".") {
      pos++;
      while (pos < expression.length && expression[pos] >= "0" && expression[pos] <= "9") {
        pos++;
        sawDigit = true;
      }
    }
    if (!sawDigit) {
      throw new Error("Expected a number at position " + start);
    }
    return Number(expression.slice(start, pos));
  }

  const result = parseExpression();
  if (peek() !== null) {
    throw new Error("Unexpected character '" + expression[pos] + "' at position " + pos);
  }
  return result;
}
```

A recursive-descent parser with the precedence levels: `+`/`-` (lowest), then `*`/`/`, then unary minus, then `^` (right-associative, binds tighter than unary minus, and its exponent is parsed as unary so `2^-1` works), then numbers and parentheses. Leftover characters or missing operands throw an `Error`.

636 tokens in, 816 out (99 of them reasoning) · 9.9 s · $0.0113 · 1 message on Pro · answered by moonshotai/kimi-k3 via Phala · September 27, 2026

Parse CSV with quoted fields

A hard prompt: “Parse CSV with quoted fields”, in full.

Passed: All 8 tests passed.

```javascript
function parseCsv(text) {
  if (text === "") return [];

  const rows = [];
  let row = [];
  let field = "";
  let inQuotes = false;
  let quoted = false; // current field started with a quote
  let afterQuote = false; // just closed a quoted field

  for (let i = 0; i < text.length; i++) {
    const c = text[i];

    if (inQuotes) {
      if (c === '"') {
        if (text[i + 1] === '"') {
          field += '"';
          i++;
        } else {
          inQuotes = false;
          afterQuote = true;
        }
      } else {
        field += c;
      }
    } else if (c === '"' && field === "" && !afterQuote) {
      inQuotes = true;
      quoted = true;
    } else if (c === ",") {
      row.push(field);
      field = "";
      quoted = false;
      afterQuote = false;
    } else if (c === "\n" || c === "\r") {
      if (c === "\r" && text[i + 1] === "\n") i++;
      row.push(field);
      rows.push(row);
      row = [];
      field = "";
      quoted = false;
      afterQuote = false;
    } else {
      field += c;
    }
  }

  // Trailing line break doesn't start a new row; otherwise flush last field/row.
  if (field !== "" || quoted || row.length > 0) {
    row.push(field);
    rows.push(row);
  }

  return rows;
}
```

568 tokens in, 367 out (7 of them reasoning) · 4.1 s · $0.0069 · 1 message on Pro · answered by moonshotai/kimi-k3 via Together · September 27, 2026

How it compares on coding

Kimi K3 beside the job's picks among every model. 13 models share the hard-problems pick, Kimi K3 among them.

Kimi K3 beside other models on coding
Model	Passed	On Pro	Cost per reply
GLM 5.3Our pick: hard problems (shared), best value	5 of 5	250 a month on Pro	$0.0015
GLM 5.3 FlashOur pick: hard problems (shared), everyday	5 of 5	60 a day on Pro	$0.0003
Kimi K3Our pick: hard problems (shared)	5 of 5	125 a month on Pro	$0.0063

On Pro: Pro's count on each model. Cost: what OpenRouter charged us per reply, on average.

Every limit is published. Paid plans also have a monthly fair-use limit on AI cost: Pro $7.50, Max $20, Ultra $42, Studio $85. Using every message on your plan at typical sizes stays under it; very large messages and heavy research use it faster. Every limit, explained.

How these runs were done

Tests. Automatic. The function runs against the prompt's tests in a separate Node.js process with a time limit and no file, network or child-process access; it passes when every test passes.

How the runs were done, and every coding prompt.

Kimi K3, and coding, elsewhere

Questions

Is Kimi K3 good for coding?

In our test runs it passed 5 of 5 coding prompts, tied 1st of the 15 models in llmwise. Every reply is on this page, so you can judge them yourself.

How many of my messages does a coding reply from Kimi K3 use?

1 message each on Pro, where it has 125 a month on Pro. The price of a message is fixed and shown before you send it, however long the reply.

How were these runs done?

The same way for every model: each prompt sent through llmwise's own pipeline, each reply checked the same way. The methods page has every prompt and how each is scored.

Claude, GPT, Gemini, DeepSeek, Grok, Kimi, and GLM, in one chat.

See what a message costs before you send it. Free is 5 messages to try; sign in with an email link, no password or card.