A 1.2M-Parameter Model Builds Real CAD Parts in FreeCAD (No LLM, I Ran It)

Author: Prompt Engineer 48 · Watch on YouTube

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: A 1.2M-Parameter Model Builds Real CAD Parts in FreeCAD (No LLM, I Ran It) · Channel: Prompt Engineer 48 · 08:20 · Watch on YouTube

Topics: AI agents, AI evaluation and benchmarks, Software engineering with AI, AI models, Local and open-source models

Summary

The video tests Taiga S1, a 1.23-million-parameter model that executes CAD commands in FreeCAD without a large language or vision model. Given an ordered feature goal, it reads FreeCAD’s live state and selects the next valid command, while dimensions and other values come from the goal. In demonstrations on a Windows laptop, it successfully builds a flange and five other showcase parts, matching the scripted teacher on every step. The video also reviews reported research results, training methods, limitations, and how to try the project.

Key points

Taiga S1 is a three-layer transformer with 1.23 million parameters; its weights file is about 6.7 MB.
A planner supplies an ordered list of features; Taiga handles step-by-step command execution in FreeCAD.
The model reads the live feature tree, sketch geometry, constraints, selection, recent commands, and goal items to choose among currently valid actions.
The goal provides dimensions and other numeric values; the model chooses command types rather than estimating those values.
The Windows demo built a flange in 27 commands with an intersection-over-union score of 1.0000, matching the scripted teacher on all steps.
All six author-provided showcase goals succeeded; the slotted wheel demo also matched its target after 28 commands.
The presenter measured a median decision time of 4.4 ms on the laptop CPU and about 10 ms per step in the live GUI run.
The model card reports strong results on longer and unseen combinations, but those author results were not reproduced by the presenter.
The project focuses on synthetic part-design work, does not plan the feature sequence, and has a reported weakness in undo accuracy.
The presenter notes Windows setup requires environment variables and describes a FreeCAD crash when saving screenshots with a transparent background.

Chapters

Start	Chapter	Summary
00:00	Introducing Taiga S1 and how it works	The video introduces the small FreeCAD command model, explains the planner-and-executor setup, and describes how it selects actions from the current application state.
01:33	Windows setup and flange demonstration	The presenter configures FreeCAD on Windows, runs integration tests, and shows Taiga building a flange command by command.
03:37	Showcase parts and performance	The video reports results for the repository’s showcase goals, examines a slotted wheel build, and discusses measured latency and author-reported evaluations.
05:10	Training, generalization, and limitations	The presenter reviews error recovery, training methods, results on unseen feature combinations, and practical limitations of the project.
07:19	How to try it and closing	The video outlines the basic steps for running the demo and reiterates that users must provide the feature plan.

Quotes

there is no big language model here, no vision model, no screenshots — 00:00

The agent plans, Taiga executes. — 01:02

27 commands in total — 03:05

The slow part is FreeCAD itself, not the model. — 04:09

it does not plan. — 07:19

Concepts and entities

Taiga S1, FreeCAD, Hugging Face, Shiv, teacher, DAgger, Part Design

Full transcript (original language)

00:00 All right, in this video we will see a tiny model, just 1.2 million parameters, build a real flange in FreeCAD command by command. And you can see that it gets the part exactly right. Now, mind you, there is no big language model here, no vision model, no screenshots, and I ran all of this on my own Windows laptop, the one with the 8GB GPU. Let’s go ahead and test this out. So, this is Taiga S1 from Shiv, and it is up on Hugging Face under the MIT license. It’s a three-layer transformer with 1.23 million parameters, and the whole safe

00:31 tensors file is only about 6.7 megabytes. What it does is build CAD parts inside FreeCAD. You give it a goal, which is an ordered list of features like a plate, then a hole, then a polar pattern, then a fillet, and it builds the part one command at a time. Select a plane, sketch, draw, constrain, pad. That’s it. Now, the idea behind it is really interesting. The author calls it a system one model. So, you have a planner, which can be a big language model, that decides what to do. And then you have this tiny model that handles the step-by-step execution. The agent

01:02 plans, Taiga executes. And the reason that matters is speed and cost. Clicking buttons does not need a frontier model. And if you look at this, the decision happens in a single forward pass on the CPU. So, how does it work? At every step, it reads the live state of FreeCAD, and that state is turned into tokens, one token for each object in the feature tree, the sketch geometry, the constraints, the current selection, the last eight commands, and the goal items. Then the commands that are valid right now become the options. The same idea as which toolbar buttons are active. Every

01:33 option gets a score in one pass, and you pick the best one. So, the action space can change at every step, which is really neat. One more thing. The model only picks the command type. The actual numbers, like the sizes, the depths, the radii, and the counts, come from the goal itself. So, the model is not guessing dimensions, it is deciding what to click next. Let’s go ahead and set it up. I cloned the repo, installed FreeCAD 1.1.4 with winget, and made a Python environment with UV. Now, the repo is built Mac and Linux first, so it did not find FreeCAD

02:04 on Windows by itself. What you can do is set two environment variables, FreeCAD_Ty and FreeCAD_Lib, and point them at the FreeCAD bin folder. After that, it just works. So, first let’s run the tests. This include integration tests that talk to the real FreeCAD, and you can see that all 16 passed in about 74 seconds on Windows. Good start. Now, for the live demo, the repo has a small macro that starts a socket server inside the FreeCAD GUI. I launch FreeCAD with that macro, and then a Python

02:34 script loads the model from hugging face and drives the app over that socket. Here is the goal, a base cylinder radius 36, height eight, then a boss cylinder on top radius 15, then a hole, then a polar pattern of six, and then a chamfer on the top edge. Five features, and let’s see what it does. And you can see it starts by creating the body, then it selects the XY plane, makes a new sketch, creates a circle, locks it, sets the diameter, leaves the sketch, and pads. Then it selects the

03:05 top face and does the same thing again for the boss. Then the whole sketch, a pocket, and now it selects the tip and runs the polar pattern. Then it selects the top edges, chamfers them, and says, “Done.” 27 commands in total, and the result says success intersection over union of 1.0000 against the target, and the model agreed with the scripted teacher on all 27 steps. That’s really great. And it is not just a flange. The repo ships six showcase goals. So, I ran all

03:37 of them. The hex nut took 19 commands, the slotted wheel 28, the enclosure 14, the mounting plate 38, and the washer 12. All six succeeded with an IOU of one, and every step matched the teacher. Mind you, these are the authors’ own showcase goals. So, this is a good start, not a full test. Let me show you one more build in detail, the slotted wheel, because it has a pattern in it. A base disk radius 32, then a center hole, then a rectangular slot sketch near the edge, and a pocket. And now you can see it select the tip and run the polar

04:09 pattern, so that one slot turns into a ring of eight. Then it fillets the top edges and says done. 28 commands. And again, the result is a perfect match. Now, let’s talk about speed. The claim is about 1 millisecond per decision. On my laptop CPU, I measured a median of 4.4 milliseconds with a 95th percentile at 6.4. So, it is not 1 millisecond here, but it is still a few milliseconds, and that is a full decision from state to command. And in the live GUI run, each step was around

04:39 10 milliseconds because that includes reading the state and talking to FreeCAD. The slow part is FreeCAD itself, not the model. Now, the numbers from the model card. These are the authors’ results. I did not reproduce them. On parts like the training set, one to five features, it builds 100% correctly. On 11 features, which is about 55 commands and longer than anything it trained on, it completed all 100 held-out goals. At 13 and 15 features, it is still 100% and at 17, it is 95. Per-step accuracy against

05:10 the teacher is 99.8%. And it recovers from mistakes. When 20% of its actions are replaced by random ones, it notices the damage, undoes it, and still finishes between 86 and 100% of the parts. That is because the training data had random mistakes mixed into 60% of the sessions. So, it learned how to fix things. Now, where does it actually miss? The author measured per-step accuracy on over 44,000 steps, and 13 of the 14 command categories are at 100%. The weak one is undo at 97.1%

05:43 across about 2,500 steps. Undo is the recovery move, so that is exactly the place you would want to watch if you push it harder. The training is also simple. 24,000 synthetic modeling sessions, around 590,000 decisions, all generated in headless FreeCAD with a scripted teacher. Then two rounds of dagger where the model drives live FreeCAD and the teacher labels what it actually visits. And then a temperature is fitted so the probabilities are calibrated. Now, if you’re into the research side, this is the interesting part. It was trained on goals of up to five features,

06:15 but it handles 11. The author found four things that mattered. Randomized position IDs during training, so it never breaks on numbers it has not seen. Coupling the goal item number with the feature tree position. A done check for each goal item, which worked better than a pointer over the whole goal. And factorize feature types for combinations it has never seen. And feature pairings that never appeared in training still came out at 90 to 100%. There is one more test I like. Combinations that never appear in training. The author ran three of them. 100 goals each. Two came out at 100%.

06:47 The third mixes a mirrored hole with a patterned boss and it got 90%. And inside that one, the mirrored hole goals are the weak part at about 80%. So, it is strong, but it is not magic and the author’s own table shows where it slips. Okay, now the honest part. First, repo is Mac and Linux first. So, on Windows, you need to set those two environment variables yourself. Second, when I saved screenshots with a transparent background, FreeCAD crashed on my machine. So, I switched to the normal background and it was fine. Third, all of this is synthetic part design work in

07:19 the part design workbench. So, do not expect it to model your random engine block. And fourth, it does not plan. Someone or some bigger model has to give it the ordered goal. Also, it is very new, about 126 downloads when I checked. But, the direction is what I like. The author says the next step is the same approach for apps that have no scripting API using the operating system’s accessibility tree. So, a big model plans and a tiny model like this one clicks locally in milliseconds. And if you want to try this yourself, it

07:49 is only a few commands. Make the environment, install the package, start FreeCAD with the server macro, and then run the demo script with the model name from Hugging Face. It downloads the weights on the first run, and then you can watch it build or change the goal file and give it your own list of features. Remember, the planner part is up to you. So, in this video, we have seen a 1.2 million parameter model build real parts in FreeCAD on a Windows laptop. If you’re interested, you can go ahead and check this out and try this out on your own system as well, and let me know how

08:20 it goes. The model is Tiger S1 by Shiv, and the links are in the description. I’ll see you in another one. Check out the next video.