Code converter

Run on October 9, 2026: 5 inputs on 19 models, each with this tool's own instructions.

Convert this code, in one code block, keeping the same names and exactly the same behaviour for every input. Then at most three lines on the differences you handled.

---
def clock(minutes):
    m = minutes % 1440
    return f"{m // 60:02d}:{m % 60:02d}"

```javascript
function clock(minutes) {
    if (typeof minutes === "bigint") {
        const m = ((minutes % 1440n) + 1440n) % 1440n;
        const hours = m / 60n;
        const mins = m % 60n;
        return `${hours.toString().padStart(2, "0")}:${mins.toString().padStart(2, "0")}`;
    }

    const m = ((minutes % 1440) + 1440) % 1440;
    const hours = Math.floor(m / 60);
    const mins = m % 60;
    return `${String(hours).padStart(2, "0")}:${String(mins).padStart(2, "0")}`;
}
```

Source language: Python. Negative modulo is normalized to match Python; BigInt inputs are supported for arbitrary-size integers.

```javascript
function clock(minutes) {
    const m = ((minutes % 1440) + 1440) % 1440;
    return String(Math.floor(m / 60)).padStart(2, '0') + ':' + String(m % 60).padStart(2, '0');
}
```
Source: Python. JS `%` keeps the sign of the dividend, so negative minutes are wrapped with `((x % 1440) + 1440) % 1440` to match Python's non-negative modulo. Integer division via `Math.floor` and zero-padding via `padStart` replicate `:02d`.

1. Paste the code: a function, a class or a short script. Up to 1,500 characters.

2. Pick the language to convert it into.

3. Press “Convert”. Without an account you see the start (1 free run a day, no account needed).

4. Run the original and the conversion on the same inputs, edge cases included, before you replace anything.

• Show how it's called

  Paste the function with the code that calls it, or an example input and output. The conversion then matches how it's really used.

• Name the version

  Say which runtime you're on (“Node 22”, “Python 3.12”, “Java 21”). Newer versions have built-ins that make the code shorter.

• Small pieces

  Convert one function at a time and test each one. A 2,000-line file converted in one go hides its mistakes.

• Tests that run on both

  Signed in, ask the same model for tests of the original's behaviour, then run them on both versions.

• Same inputs, same outputs

  Run the original and the conversion on the same inputs, including an empty one, a negative number and text with odd spacing. Where the outputs differ, the conversion is wrong.

• Arithmetic on negatives

  Python's -7 % 3 is 2; JavaScript's is -1. Python's // rounds down; a naive Math.trunc rounds toward zero. Check every % and division when negatives can occur.

• Library functions that look alike

  Ruby's split() drops empty pieces; JavaScript's split(" ") keeps them. Python sorts “B” before “a”; localeCompare doesn't. These small differences are where converted code quietly breaks.

• Idiomatic, not literal

  A good conversion uses the target language's own style (a list comprehension becomes map, a dict becomes an object or Map), not a line-by-line transliteration.

• Without an account: 1 free run a day, on GPT-6 Luna, shared with the free message on our home page. It takes up to 1,500 characters, writes up to about 600 tokens (roughly 450 words), and shows you the start of the conversion.

• Signing up is free, with an email link and no card. llmwise accounts are for people 18 and older. The conversion you ran comes with you as your first chat, and you get 5 free messages on almost every model (all but Claude Fable 5.1 and GPT-6 Astra).

• Signed in, paste up to 20,000 characters in a run. It runs on the model you pick, on your plan, shows the whole answer, and you can carry on in the chat with any model.

More free tools are on the tools page, and what each plan gives is on pricing.