Qwen 3.6 27B contra Gemma 4 31B: dos models locals construeixen la mateixa app Tauri

After I tested Qwen 3.6 on tasks of varying complexity, I realized that this model is fully ready to take the role of the main local model I use. However, since that role is currently held by Gemma 4, the logical next step for me is to compare them and choose a winner. It is important to note that I will not be doing abstract benchmarking or trying to compare the models objectively. On the contrary, I want to find out which of these models suits me personally, for my specific tasks and on my specific hardware. Still, I hope the results of such a comparison will also be interesting to you and that you will be able to draw some useful conclusions for yourself. So, the first thing I need is to come up with a comprehensive test for the models in order to understand where the limits of each of them lie. But at the same time, I would like to get some extra value from these tests, rather than simply throwing away the generated code afterward. While thinking about such a test, I remembered that a few days ago, I couldn't quickly find a markdown file viewer for macOS that

suited me. At the time, I postponed the task so I could calmly look for one over the weekend. But now, remembering that situation, I decided that building a desktop app for viewing or perhaps even editing and viewing markdown files would be a very good and sufficiently challenging test for AI models. So, I quickly wrote a short description of the markdown editor I want to get. Although it will probably be more of a viewer with editing capabilities rather than a full editor, since convenient viewing is the main priority for me. But the ability to quickly make changes is also important. And briefly about the technology stack I chose. For this application, I decided to use the Tauri framework. I have used it for a long time, I like it, and it has proven itself well in many of my previous projects. It will also allow me to make the application cross-platform, which will be useful for me as well. Now, let's get back to the models. For both Gemma and Qwen, I will use dense models of the largest size that my graphics

card can handle. I explained in detail why I prefer dense models in my previous video about Qwen 3.6, where I compared different AI model architectures. In short, for tasks related to writing code, dense models tend to deliver better results. So, today I will be comparing the 27 billion parameter Qwen 3.6 model with the 31 billion parameter Gemma 4 model. Both will be launched one after another on my desktop computer, and I will use them over the local network from my MacBook. On the screen, you can see the specifications of this desktop. If you also decide to run these models yourself, the main thing to pay attention to is making sure your graphics card has plenty of memory. That is the most important parameter for running LLM models. So, for today's test, I created a separate folder containing two subfolders, one for each model. Inside each folder, I placed the same file in which I briefly described my vision of the application I want to get. I think I'll start with the Qwen 3.6 model. I go

into its folder and launch Open Code. That's what I'll be using today. I already have both of these models connected in Open Code, so I simply select Qwen. Since the markdown editor task itself is quite complex, the first thing I asked the model to do is analyze my description and create detailed implementation plan breaking everything down into small tasks. All right, I won't show the response generation process. It took about 4 minutes, and there was nothing particularly interesting there. So, I'll jump straight to the result. As I requested, the model wrote the plan and tasks into a separate file. Let's take a look at it. As you can see, the entire development plan is divided into phases, and each phase is split into smaller tasks. The tasks contain specific descriptions of what needs to be done along with important nuances. Overall, I like this plan. It looks like Qwen handled the planning stage well. All right, now I'll launch Open Code again and run the init command in this folder

so the agent can understand what kind of project this is and review both the application description file and the file containing the plan and tasks. Well, then, now we can finally move on to actually implementing the project. I asked the model to complete all the tasks from the plan one by one while making decisions on its own whenever possible. Of course, the proper way to work on a project would be to implement it gradually, phase by phase, or even one task at a time. But, I want to do a kind of stress test for the model and see how well it can independently work on a complex project for a long period of time. As you can see, the model has started actively reasoning through the tasks. I think the whole response generation process will take quite a while, so of course I won't show all of it, but I'll mention at the end how long it took. It is encouraging that the model identifies its own mistakes during the process and thinks about how to fix them. Excellent. So, the model has finally finished working on the project. It took about 46 minutes. Of course,

that is quite a long time, but for a local model working on a complex task, it is a acceptable result. Now, let me try to launch what the model generated. I doubt everything will work immediately, but let's see. Yes, unfortunately, the application did not start and instead shows an error. Something is wrong with the front end. I suspect the port may be set incorrectly. Let me check. Oh, that is strange. The entire block responsible for starting the server is missing. I'll have to add it manually, but that's nothing serious, just a couple of lines. Now, I'll try launching it again. Oops, another error, this time in the Rust code. But, no problem. I think I know what the issue is. I ran into a similar error once before. The problem is that Qwen used a method from the old version of Tauri, the first version. Now, that method has a different name. That is also just a minor fix. All right, then. Let's try launching it one more time. And finally, everything started without errors. That is already

encouraging. But, now we need to see whether the application actually works in principle. All right, for an initial version, it looks quite good. There is even a toolbar. The window is split into two sections. Most likely, one side is meant for text input and editing, while the other is for previewing the result. Excellent. The editor responds properly to text input and the real-time preview works correctly. Great. Now, I'll try something like recursion and open the Markdown editor development plan inside the editor itself. Oh, excellent. The file opened and displayed without errors. If I add something to it, the result is immediately shown in the preview window. Perfect, but it seems the toolbar buttons behave somewhat strangely, and the editing buttons apparently do not work at all. There is no reaction when pressing them. That can all be fixed gradually. The important thing is that there is a working foundation. It would be strange if everything worked perfectly from a single prompt to the model. So, the result I got is very good. I'm

impressed, even despite the minor launch errors. Well, then, now it is Gemma 4's turn. I move to a separate folder for this model. Inside it, I have the same project description file as I used for Qwen. I launch Open Code and switch the model to Gemma 4. Then, I give it the same task as before, to create a complete implementation plan for the project and break it down into small tasks. Interestingly, this model handled the planning stage faster. It took 2 and 1/2 minutes. Just as I requested in my prompt, the plan was written into a markdown file. Let's take a look at it now. Just like the plan created by Qwen, this plan made by Gemma breaks the entire process into phases, and each phase contains separate tasks with specific descriptions of what needs to be done and what to pay attention to. Excellent. I also want to open both plans side by side so I can compare them visually. They are quite similar. Surprisingly, the plan created by Qwen contains almost twice as many phases into which the project is divided.

Accordingly, it also contains more tasks. It will be interesting to see how that affects the final result. All right, I switch back to Open Code, and just as I did for Qwen, run the init command. After the command finishes, I send the same request for full project implementation. I change nothing. For Gemma, everything is exactly the same, word for word, as it was for Qwen. All right, the model has started working on the project, and once again, I will skip this long and tedious part and show the result when it finishes implementing the plan. And while the model is working, I'll show you how much power the desktop consumes under active load. This is an important point that many people overlook, because if your local model is running constantly, your monthly electricity bill can increase significantly. So, the model has finally finished. The entire process took 20 minutes. That is twice as fast as the previous model. As a reminder, Qwen took 46 minutes. Not bad, but the real question is the result. By the way, I

really liked how Gemma listed all the tasks it worked on at the end of its response. All right, I exit open code and try to launch the application created by the Gemma model. So far, everything is compiling successfully. But no, it still did not launch on the first try and there is some kind of error. All right, let's see what the problem is. It looks like the issue is on the rust side. Something related to file system access. Okay, I'll debug it and then come back to you with the result. So, I figured out what the problem was. The issue was that the configuration did not include the plugins responsible for working with the file system. However, they were used correctly in the code itself, so all I had to do was add them there. All right, now after these fixes, I'll try launching the application again. The compilation process has started. So far, there are no errors, which is encouraging. Hooray, the application launched. Great. Let's take a closer look at it and test it. So, we are greeted by a similar

two-panel interface. Text input and rendering work correctly. The buttons that switch the editor between editing mode and preview mode also work properly. Excellent. Now, I'll check whether it can open a markdown file from disk. By the way, notice that Gemma moved all the original files describing the program, as well as the development plan, into a separate documentation folder. Even though I did not ask it to do that, I like it. It makes the repository look much cleaner. All right, the file opened without any problems. All the markdown in it is displayed correctly. Excellent. It is safe to say that Gemma also successfully completed the task. Well then, it is time to sum everything up and draw some conclusions. In my opinion, even despite the minor bugs when launching the applications, both models successfully completed the task. They were placed in a fairly stressful situation and had to implement the entire plan at once, which in itself is already quite challenging. But as I said

before, I did that intentionally. As for who won today's test, in my view, both models delivered very similar results. What I liked about Qwen was that it created a more detailed plan. However, it also had more initial errors that I needed to fix before launching the application. Gemma, on the other hand, completed the project twice as fast, but it completely ignored creating toolbar buttons for text formatting, which is strange since it had created tasks for that in its own plan. So, I will probably continue using both of these models together, and over time I hope I will be able to settle on just one of them. Write in the comments whether you have already tried these models and which one you like more and why. I would be interested to hear your opinion. I think that will help me make a choice between them. That is probably all for today. If you enjoyed this video, leave a like and subscribe so you don't miss the next episodes. See you soon. Take care of yourself.