Qwenputer applies Qwen3.5 to RISC-V CPU design. The interesting question is not whether AI can produce chip code, but whether that code executes, produces reproducible results, and can be verified beyond visual inspection.
Original technical article: https://divagr.com/blog/qwenputer. The project reached the Hacker News front page with 65 points and 11 comments.
What Qwenputer Actually Built
Qwenputer has a specific goal: use Qwen3.5 to implement a working, deterministic RISC-V CPU.
The challenge is not simply generating a block of Verilog or assembling a repository that resembles a processor in a chat window. The code must run, its results must be reproducible, and the design process must withstand scrutiny.
For most LLM code-generation tasks, the deliverable is a Python, JavaScript, or Rust program. The job is done once the tests pass and the functions return the expected results.
CPU design adds another layer of constraints:
- Instructions must conform to the RISC-V specification;
- State transitions must satisfy timing requirements;
- The same input must always produce the same output;
- Failures cannot be dismissed as looking correct in code; they require executable tests.
Qwenputer’s core deliverable is therefore not a demonstration snippet, but an executable RISC-V CPU implementation. The project emphasizes functional completeness and determinism.
These are two distinct properties.
“Functional completeness” means the processor can execute the intended instructions and perform its basic work. “Determinism” means the outcome remains consistent when the inputs, state, and execution conditions remain unchanged.
The second property may sound unremarkable, but it underpins a closed-loop hardware verification process. If tests produce different results on every run, failures become difficult to diagnose. Designers also cannot tell whether a problem comes from a new change, an old defect, or the verification environment itself.
Running Is Harder Than Generating
There is a full verification chain between generating a block of Verilog and building a CPU that runs.
For a RISC-V processor, at least four areas need to be checked:
- Instruction set: The supported instructions, register encodings, and exception behavior must conform to the specification.
- Timing: The design must establish when data becomes available, when state is updated, and whether race conditions exist.
- State transitions: Each instruction must have a defined effect on the PC, registers, and memory state.
- Test results: Programs must produce the expected output, and repeated executions must remain consistent.
All four areas must fit together.
A successful compilation proves only that the syntax is valid and some connectivity is correct. An occasional passing test does not prove that state transitions are sound. If the same program yields different results on consecutive runs, its test report loses much of its diagnostic value.
The engineering workflow can be reduced to this sequence:
Instruction requirements → RTL implementation → Simulation → Test programs → Result comparison → Defect fixes → Regression testing
A model’s ability to handle one or more stages does not mean it completed the entire chain independently.
Qwenputer is more revealing because it places code generation in an environment where surface-level correctness is not enough. Returning the right value is insufficient. Ending a loop is insufficient. A CPU must maintain correct state over time and continue to follow the specification across combinations of instructions.
Qwen3.5’s Role Goes Beyond Writing Code
Qwen3.5 has at least three roles in the project.
The first is code generation: writing RTL, tests, build scripts, and supporting tools from design requirements.
The second is implementation debugging: locating problems from compiler errors, simulation failures, and test logs, then revising the implementation.
The third is design decision-making: selecting a pipeline structure, choosing between single-cycle and multi-cycle execution, defining exception handling, and deciding which features belong in the first version.
The model can take on more of the first two roles directly. The third depends on constraints, experience, toolchains, and project tradeoffs.
This distinction is often blurred when evaluating AI chip-design demonstrations.
“The model generated CPU source code” does not mean “the model invented a processor from scratch.” People still have to define the goals, select the instruction set, provide the verification environment, and determine whether the tests cover the issues that matter.
Qwenputer’s value lies in placing its implementation inside a runnable verification environment rather than merely showcasing generation. Everything the model produces must respond to tool feedback; the model cannot simply declare the work complete.
Why RISC-V Suits AI Hardware Experiments
RISC-V’s open instruction set and mature toolchain lower the barrier to AI hardware experimentation.
It is not a proprietary instruction set owned by one company. Developers can implement processors around the specification and connect them with compilers, assemblers, simulators, and debugging tools. This environment is especially useful for LLM experiments because the specification is public, errors are traceable, and test results are easy to reproduce.
Being suitable for experiments, however, does not mean being suitable for production.
A teaching CPU may use a simple single-cycle design, cover a limited feature set, and handle only the timing and exception cases required by a course or lab. It can demonstrate that AI can participate in hardware implementation, but it does not show that a chip of comparable complexity can be fabricated. Nor does it establish that performance, power consumption, area, and yield have met production targets.
A production processor must also address:
- Performance and frequency constraints;
- Physical implementation, timing closure, and power analysis;
- Security mechanisms and formal verification;
- The software ecosystem and long-term maintenance;
- Numerous edge cases not covered by basic tests.
RISC-V addresses open interfaces and experimental cost. It does not automatically remove the most expensive parts of hardware engineering.
Editorial Assessment
Qwenputer is better understood as a runnable example of an AI-assisted hardware engineering workflow than as proof that a model can autonomously design chips. It differs fundamentally from earlier text-generation demonstrations: a CPU implementation must execute instructions, manage state, and pass deterministic tests. When something fails, designers must return to simulation and logs rather than merely repair code that appears plausible.
That difference shifts the evaluation from whether the code looks convincing to whether it runs and whether its results can be reproduced. The available material, however, does not establish whether verification coverage is complete or how much responsibility the model carried in architectural tradeoffs.
The next meaningful metric is not the number of Verilog lines, but whether independent tests can reproduce defects reliably and how often humans need to intervene. As long as the verification chain depends on the author’s own assurance, AI-assisted chip design remains an engineering aid rather than an autonomous discipline.