void

I learned online that Void is an open-source AI code editor — practically an open-source alternative to Cursor. It’s powerful, compatible with all kinds of models, and supports local execution, giving users full control over their own data and making it genuinely safe and controllable.

I tried out this IDE that allows local AI execution, to see how it actually performs.

The test case I picked: ask it to generate an English word spelling quiz (web page) for me, for elementary school English practice.

First, write the requirement prompt:

I want to create an HTML page in the wordspell-exam directory to implement English word spelling practice. I can configure lots of words in the code, and each time the page is opened it randomly generates 20 word questions from the configured word bank, letting the user answer them one word at a time.
For each word question, the screen displays full-screen: the top line is the Chinese question in large text, the middle line is an input box that visually indicates the number of characters in the word (similar to the 6-digit verification code style used on most websites); the bottom line is a confirm button.
Clicking confirm moves on to the next question. Once all the word questions are answered, the result and score are shown automatically.
The result needs to include the incorrect words and their correct answers, with the score converted to a 100-point scale.
When showing the answer, it also needs to send a webhook.

  • Webhook request URL: 'https://open.feishu.cn/open-apis/bot/v2/hook/yyyyyy-xxxxxxx'
  • Request method: POST
  • Request headers: Content-Type: application/json
  • Request body: {"msg_type":"text","content":{"text":"request example"}}
    Make the UI modern and minimal, adapted for iPad and PC.

First test: void with LM Studio’s Qwen3-30B-A3B MLX 4-bit quantization

Very disappointing. It didn’t hit all the targets.
In the first attempt, the questions it produced were in English, the answers were in English, and there was no character-count box.

Second test: refining the prompt

For the second attempt, I first converted the prompt into a more logical planning document.

The converted prompt:

🎯 Background

We want to develop an HTML page for English word spelling practice in the wordspell-exam directory, for users to train on spelling individual words. The page needs to have the following features:

🧩 Feature breakdown

1. Word bank configuration

  • Build in a word list (array) in the HTML or JS, for example:
    const wordList = [
  { en: "apple", zh: "苹果" },
  { en: "banana", zh: "香蕉" },
  // ...more words
];
  • Every time the page is opened, randomly draw 20 words from this word bank as the questions for that session.

2. Answering interface

  • Show only one word at a time, and the user answers them one by one.

  • The layout is as follows:

    [Full screen]

Chinese question (large text)

-------------------
|                 |
|     _ _ _ _     | (input box, shows character count)
-------------------

[Confirm button]

  • Input box style: like a verification code field, e.g. ____ (4 underscores), adjusted automatically based on word length.

  • The input box only allows letters, case-insensitive.

3. Answering flow

  • The user types the word in the input box and clicks the “Confirm” button.
  • The system determines whether it’s correct:
    • Correct: move to the next question
    • Incorrect: log the error and move to the next question
  • After all questions are answered, automatically jump to the result page.

4. Result display

  • Show the total score (100-point scale)
  • Display all incorrect words and their correct answers
  • For example:
    Incorrect: apple → correct answer is "apple"
Incorrect: banan → correct answer is "banana"

5. Webhook sending

  • After the result page is generated, automatically send a POST request to the specified address:
    • URL: https://open.feishu.cn/open-apis/bot/v2/hook/xxxxxxxx
    • Method: POST
    • Headers:
      Content-Type: application/json
    • Body example:
      {
  "msg_type": "text",
  "content": {
    "text": "User completed the spelling exercise, score: 80%"
  }
}
    • Note: the content actually sent should include the user’s score, the list of incorrect words, and so on. The exact format is up to you.

6. UI design

  • Clean, modern style, adapted for PC and iPad.
  • Use responsive design (such as Flex or Grid) to ensure it displays properly on different devices.

🧰 Technical suggestions (for the programmer’s reference)

  • Front-end tech: HTML + CSS + JavaScript
  • State management: you can use let or const variables to hold the current question number, user input, error log, etc.
  • Styling suggestions: use flex layout, large fonts, reasonable spacing
  • Mobile adaptation: use the viewport setting and media queries (Media Query)

✅ Summary

The core of this page is:

  • Randomly draw 20 questions
  • Answer question by question, showing the character count
  • A result page displaying the score and error information
  • Automatically send a webhook

Then I had it do the work. Well, well — it just wrote it in Python.

So where’s the problem? A 30B model can’t possibly fail to understand even a requirement like this, right?

Switching the Qwen models to 8-bit quantization

I wasn’t happy with Qwen3-30B-A3B 4bit, and suspected it was a quantization issue.

I was going to switch to 8-bit quantization, based on this information:

  • I looked things up and someone said the unquantized version of Qwen3-4B is already very strong.
  • I asked Doubao, and it said 8-bit quantization performs close to the full-size version, while 4-bit quantization shows an obvious drop in performance.

So I planned to first switch to Qwen3-14B-MLX 8bit (16GB), which can run smoothly, and test its performance; then verify further with Qwen3-30B-A3B 8bit (32.46GB), hoping for better results.

Testing Qwen3-14B 8-bit

I tested the 14B together with void, but found a problem — void kept throwing errors. I raised the context to 40960 and continued again.

Still throwing errors.

Error: Unable to write file '/Users/rhett/MyWork/2025/AIToolWorkspace/wordspell-exam/spell_practice.html <content> <!DOCTYPE html> <html lang="zh-CN"> <head> <meta charset="UTF-8"> <title>英语单词拼写练习</title>...

How odd. Let me switch to 30B-A3B-4bit and try again — this time it could generate HTML, but it didn’t automatically insert it into the file, only showed it in the agent conversation. Yet the void agent panel showed no errors.

Testing Qwen3-30B-A3B

Switched to 30B-A3B 8-bit; same as 4-bit — it generates HTML but can’t automatically write it to a file, and it didn’t fully grasp the requirements, e.g. it never implemented the webhook submission requirement at all.

Observations:

  • The Qwen3-14B Dense model at 8-bit runs noticeably slower than the Qwen3-30B-A3B MoE at 4-bit. It uses a bit less memory but is slower.
  • Qwen3-30B-A3B 8-bit is also faster than 14B, which shows that Dense models aren’t as fast as MoE.
  • Void probably hasn’t adapted well to the Qwen models in some respects, which is why content can’t be inserted into a specific file.

Adjusting void’s parameters and trying Qwen3-30B-A3B 8-bit again

Even with Qwen3-30B-A3B, it couldn’t properly understand my requirements — I was shocked. It couldn’t even restate the six requirements I laid out. It all felt like hallucination.

After dinner that evening, with a clearer head, I looked into the configuration again and happened to discover a setting: next to the model toggle there’s a plus sign; clicking it opens advanced settings. By default it sets contextWindow to 4096 and reserved to 8192. After I changed it to 40960 to match my LM Studio settings and reduced reserved, it finally understood my requirements:

The HTML it output after understanding the requirements looked correct, but—

The problem with this version was that the code threw errors when run in the browser.

I checked it by hand and found that the 30B’s code had problems with how the pieces fit together. Could it be that Qwen 30B isn’t suited to writing code?

Switching to openrouter/qwen2.5-coder-32b (free) for testing

Noticeably much slower than the local 30B.

It can automatically perform the file-write operation after outputting the HTML!

The code runs without errors, fully implements all the requested features, completes the word spelling and checking flow, and also submits the webhook.

Strange — does Void only write files when paired with a coder model?

I haven’t deployed this model locally yet, so I can’t confirm whether being unable to automatically write files in void is a local deployment problem or a qwen3 model problem. And there’s no need to verify it — cloud calls are free anyway, so there’s no need to run it locally.

Hmm, it looks like the most reliable free option with void right now is this openrouter/qwen2.5-coder-32b (free) model.

Doubao’s take on which models write code better

On the model tiers you mentioned:

  • Qwen2.5-Coder-32B-Instruct:Free: mid-to-upper tier, suitable for everyday development tasks, performs well in Chinese-language programming scenarios.
  • DeepSeek-R1-Zero:Free: entry-level, suitable for simple code generation and learning, with limited support for complex tasks.
  • Qwen3-30B-A3B: a high-end model with strong code understanding and generation ability, capable of handling complex development needs.

Recommendations:

  • Beginners or simple tasks: pick a free entry-level model such as DeepSeek-R1-Zero:Free.
  • Professional developers: use a high-end model such as Qwen3-30B-A3B or GPT-4 Turbo.
  • Chinese-language scenarios first: the Qwen series is a good choice.

Why did my test case today make qwen2.5-coder-32b feel more reliable than Qwen3-30B-A3B? Looks like I need to keep observing.

Next week I plan to test further in a mini program development scenario, to see which one is more reliable at writing mini program projects.

Summary

  • Void is an open-source AI code editor that can be used as an alternative to Cursor.
  • Void supports local execution, letting users take full control of their data and keeping it safe and controllable.
  • The test goal was to use Void to generate an HTML page for an English word spelling quiz.
  • In the first test, the model didn’t fully understand the requirements, and the generated content didn’t match expectations.
  • After refining the prompt, the model still failed to generate the HTML page correctly and instead output Python code.
  • After switching to the 8-bit quantized versions of Qwen3-14B and Qwen3-30B, the model still had comprehension gaps and missing features.
  • Void made errors when writing files, which may be related to model adaptation or configuration.
  • After adjusting Void’s context window setting, the model began generating HTML content correctly, but the code had runtime errors.
  • When using the Qwen2.5-Coder-32B model on OpenRouter, the model was able to generate and write the HTML file correctly.
  • Qwen2.5-Coder-32B outperformed Qwen3-30B-A3B in testing and suits the current requirements.
  • Going forward, I plan to test different models further in a mini program development scenario.
License

Licensed under CC BY-NC-SA 4.0. Please credit the source when reposting.

Join the discussion