Hi! I like PHP, Javascript, and so forth, and I'm just getting into ollama and trying to figure out which models I should use. So I ran some tests and wrote some long, windy blog posts. I don't want to bore you with those so here's a gpt-oss:120b generated re-write for freshness and readability of what I came up with. Although, I did check it and edit a few things. Welcome to the future!

Title: Llama 3.3 70B vs GPT‑OSS 20B – PHP code‑generation showdown (Ollama + Open‑WebUI)

TL;DR

Below is a single, cohesive post that walks through the experiment, the numbers, the code differences, and the final verdict.

1. Why I ran the test

I wanted a quick, repeatable way to see how Ollama‑served LLMs handle a real‑world PHP task:

Read a text file, tokenise it, build an array of objects, write a JSON summary, and re‑create the original file.

The prompt was deliberately detailed (file‑name handling, whitespace handling, analytics, etc.) and I fed exactly the same prompt to each model in a fresh chat (no prior context).

2. Test harness

3. Speed & latency

Even though Llama 3.3 felt “slow to start”, it still finished within a minute and a half. GPT‑OSS was noticeably snappier.

4. Code size & structure

Overall, I much prefer the kind of commentary and code structure produced by GPT-OSS.

4.1. Sample header comparison

GPT‑OSS 20B (first ~12 lines)

<?php
/**
 * a1.php
 *
 * 1. Reads a text file (via GET or POST: file=)
 * 2. Tokenises it into words & whitespace
 * 3. Builds an array of objects:
 *      - id          : the token number in the file
 *      - t           : the exact token as it appears
 *      - whitespace  : true for whitespace tokens, false otherwise
 *      - w           : processed word (keeps dash/apostrophe, removes punctuation)
 * 4. Stores the array, word‑count and elapsed time in JSON
 * 5. Writes a plain‑text file that contains all obj->t in order,
 *    with “‑2” inserted before the extension.
 *
 * The script is deliberately written step‑by‑step for teaching.
 */

Llama 3.3 70B (first ~12 lines)

<?php
// Combine GET and POST requests
$request = array_merge($_GET, $_POST);
// Check if file is provided
if (!isset($request['file'])) {
    echo "Error: No file provided.";
    exit;
}
$filename = $request['file'];
// Set output filename
if (isset($request['out']) && $request['out'] != '') {
    $output_filename = $request['out'];
} else {
    $parts = explode('.', $filename);
    $output_filename = $parts[0] . '.json';
}

The GPT‑OSS header reads like a short design document, while Llama’s header is non-existant. GPT-OSS wins hands down on structure and commenting.

5. JSON output quality

Both models produced human‑readable JSON in the majority of runs. The main hiccups:

All other runs generated a complete JSON object with num_words, processing_time, and the full token array. However, some runs of Llama3.3:70b-instruct produced correct but unreadable (by humans) JSON code.

6. Re‑creating the original text file

7. Readability & developer experience

7.1. Llama 3.3 70B

Pros

• Generates usable code quickly once the first token appears.
• Handles most of the prompt correctly (JSON, tokenisation, analytics).

Cons

• Inconsistent naming and variable choices across runs.
• Sparse comments – often just a single line like “// Calculate analytics”.
• Occasionally introduces subtle bugs (extra newlines, wrong filename).
• Useless comments after the code. It's more conversational.

7.2. GPT‑OSS 20B

Pros

• Very thorough comments, broken into numbered sections that match the original spec.
• Helpful “tips” mapped to numbered sections in the code (e.g., regex explanation for word cleaning).
• Helpful after-code overview which reference numbered sections in the code. This is almost a game changer, just by itself.
• Consistent logic and naming across runs (reliable!)
• Consistent and sane levels of error handling (die() with clear messages).

Cons

• None worth mentioning

8. “Instruct” variant of Llama 3.3 (quick note)

I also tried llama3.3:70b‑instruct‑q8_0 (4 runs).

• Latency: highest 30 s – 1 min to first token, ~2 to 3 min total.
• Code length similar to the regular 70 B model.
• Two runs omitted newlines in the regenerated text (making it unreadable).
• None of the runs correctly handled the output filename (all clobbered story-2.txt).

Conclusion: the plain llama3.3 70B remains the better choice of the two Llama variants for this task.

9. Verdict – which model should you pick?

My personal take: I’ll keep Llama 3.3 70B in my toolbox for quick one‑offs, but for any serious PHP scaffolding I’ll reach for GPT‑OSS 20B (or the 120B variant if I can spare a few extra seconds).

10. Bonus round – GPT‑OSS 120B

TL;DR – The 120‑billion‑parameter variant behaves like the 20 B model but is a bit slower and produces more and *better code and commentary. Accuracy goes up. (≈ 100 % correct JSON / filenames).

12.1. What changed compared with the 20 B version?

• Latency: The larger model needs roughly twice the time to emit the first token. Once it starts, the per‑token speed is similar, so the overall time is only 10-30 s longer.
• Code size: The 120 B model adds a few more helper functions (e.g., sanitize_word(), format_elapsed_time()) and extra inline documentation. The extra lines are mostly comments, not logic.
• Bug pattern: All of the same bugs that appeared in the 20 B runs re‑appear (wrong *.json.json filename, correct “‑2” suffix). In addition, run 3 introduced an unwanted newline when rebuilding the original file:

```php function rebuild_text(array $tokens, string $filename): void { $fh = fopen($filename, 'w'); foreach ($tokens as $tok) { // The 120B model mistakenly adds "\n" here in one of the runs fwrite($fh, $tok->t . "\n"); } fclose($fh); }

11. Bottom line

Both Llama 3.3 70B and GPT‑OSS 20B can solve the same PHP coding problem, but they do it with different trade‑offs:

• Llama 3.3 70B – smaller, faster to read once generated, but inconsistent and occasionally buggy.
• GPT‑OSS 20B – larger, more verbose, but gives you a ready‑to‑read design document in the code itself.

If you need quick scaffolding and are comfortable fixing a few quirks, Llama 3.3 70B is still a solid free option.
If you prefer well‑commented, “just‑drop‑in” code and can tolerate a slightly larger file, GPT‑OSS 20B (or its 120B sibling) is the way to go.

Happy coding, and may your prompts be clear!