HNHacker News
TopNewBestAskShowJobs

YuechenLi

352 karma · joined February 27, 2026

Oh boy.

yuechenli at outlook.com

submissionscomments
YuechenLi··on Show HN: Popkern – open-source CAD kernel with G2 corner blends, browser IDE
Wow, I'm glad I'm not the only person insane enough to make a geometric modeling kernel solo with LLMs. Did a quick review of the architecture, it's probably the strongest conventional kernel that's currently open source, much more advanced than Truck or SolidCore/SMLib currently.

(I'd like to think my own kernel is little bit ahead of you architecturally though.)

How's the Boolean and fillet/chamfer robustness currently in Popkern?

Also, would you like to collaborate and compare notes? It's a lot of work trying to maintain something like this solo.

https://github.com/yuechen-li-dev/Aetheris

YuechenLi··on Type Server Protocol
Interesting. Look up "semantic compression", and you can also try out one of my experiments to see if it works for you.

https://github.com/yuechen-li-dev/GenerativeCompressionProto...

YuechenLi··on Type Server Protocol
Out of curiosity, may I ask what the big unrelated problem is?
YuechenLi··on Type Server Protocol
At this point, Python is less of a programming language by itself but more of an interop protocol between various C/C++/Fortran/Rust binaries. But again, it's just part of the cycle, Python was a breath of fresh air 10 years ago when academia is still dominated by Matlab, but now it is mostly a mess of a language that's good for throwaway scripts but not very convenient for large software projects compared to statically typed languages.
YuechenLi··on We should be more ambitious with the software we build
https://github.com/yuechen-li-dev/Aetheris

Already made the geometry kernel. So far, nobody has offered me even like 20 dollars to license it yet, nevermind millions of dollars.

YuechenLi··on Show HN: SolidCraft – Open-Source Parametric CAD in Rust (With MCP Support)
Aetheris generates STEP AP242 BREP directly, the tessellated mesh generated is only used for display (although currently, I've switched to a WebGPU based SDF representation so the surfaces can be smooth). One of the key differences in the architecture Aetheris doesn't export rational b-splines outside of debug or STEP passthrough and instead tries to recover and export analytical and non-rational splines instead.

On screw thread, if you mean by "how do you make a screw thread in Aetheris", you can check out the actual code for a threaded bolt I built for a showcase here with the JSON like DSL called Firmament:

https://github.com/yuechen-li-dev/Aetheris/blob/master/fixtu...

So, the high-level surface language of defining a screw thread is basically a struct/record that looks like:

    Thread MainThread {
        Surface: face(Bolt.Shank)
        MajorDiameter: 8mm
        Pitch: 1.25mm
        Length: 47.5mm
        StartOffset: 1.5mm
        }
Which is why I said that it's really hard to think of an editor UI for Aetheris that's not just a text editor or a ComfyUI like graph visual programming or something.

If you mean compile speed wise, not great right now, it wasn't that much of an issue when running on RyuJIT natively since it's still acceptable, but currently WASM cold compile speed for a moderately sized assembly is around 4-5 minutes so there is a lot more work to be done before I'm ready to put it on a cloud server.

YuechenLi··on Show HN: SolidCraft – Open-Source Parametric CAD in Rust (With MCP Support)
I think I've seen ports of OCCT to Rust as well as Rust wrappers for OCCT floating around Github once or twice already.

However, OpenCascade being C++ instead of Rust is the least of its problems, the main issue is OCCT's boolean/blend engines aren't really as robust as the commercial kernels, and handling arbitrary 3D boolean edge cases one by one correctly is one of the main difficulties of a geometry kernel.

Very interested in SolveSpace's progress on this really.

YuechenLi··on Show HN: SolidCraft – Open-Source Parametric CAD in Rust (With MCP Support)
Well, this is more similar to a linter/borrow checker than anything else, because if you catch errors at compile time, the bad geometry doesn't persist in the STEP artifact that's being generated, so analogous to the philosophy of Rust vs C++ really.

The current design is meant to be import tolerant but export strict, it imported most STEP file I throw at it fine after a bunch of fixes, but I don't really have a big enough sample corpus know for sure how much real world STEP file it can handle.

YuechenLi··on Show HN: SolidCraft – Open-Source Parametric CAD in Rust (With MCP Support)
A sliver is basically a tiny degenerate geometry in the micro/nanometer scale that's basically the result of ambiguous surface intersections. Basically, if you put two say, cylindrical surfaces against each other in NURBS form, floating point noise would generate these microscopic geometric noises, and a lot of what commercial kernel does is they use what they call "healing" operations to clean up those bad microscopic geometries from the models they generate.

Aetheris took a very obvious approach that not many have seemed to tried before: It throws an error when an operation that may create ambiguous intersections and refuses to materialize bad geometry in the first place, which is not really possible to do with traditional NURBS based kernels, whereas Aetheris can because it is analytical first.

YuechenLi··on Where is all the new, good software?
Yeah, the Photocraft (or whatever that photoshop clone name is, naming everything *craft just blends the names together in my head) program, for example, is way too slow in WASM to be usable, I think it ran on a single thread without using Worker and basic optimization features like that.

Just because you can throw tens of thousands of dollars at frontier LLMs doesn't mean what they write would be good, you still need to have some oversight for their work.

YuechenLi··on Show HN: SolidCraft – Open-Source Parametric CAD in Rust (With MCP Support)
> Creating a b-rep kernel is a phenomenal amount of work

Well, I did it, took 6 months, and I think I'm ahead of Truck on that front since as far as I can tell Truck can still only do single edge fillets with Newton's method as their new fillet algorithm, whereas my kernel can do planar fillet chains fairly reliably.

I wish someone would wrap a frontend around it too considering I'm bad at designing UIs, and the architecture is too weird to put a conventional 3D CAD UI on it that I'm honestly hoping someone would throw their LLM at that task.

https://github.com/yuechen-li-dev/Aetheris/

Also, sorry about the excessive self-promotion, but I think most people would be shouting from the mountaintop if they built a BREP geometry kernel from scratch solo too.

YuechenLi··on OpenSCAD the Programmers Solid 3D CAD Modeller
OpenCascade is an almost 30 year old C++ codebase that's known for being notoriously difficult to integrate.

The bigger issue is that OpenCascade is error tolerant to a fault, which allows it to import a lot more legacy geometries, but it also means that it silently exports a lot more bad geometries much more often than commercial kernels

So, there's a reason why commercial solutions don't really use OpenCascade over ACIS/Parasolid for authoring.

YuechenLi··on OpenSCAD the Programmers Solid 3D CAD Modeller
STEP is a weird standard and one of the reasons it's weird is because it allows you to store tessellated mesh in the file with no BREP. Wrapping an STL mesh inside a STEP container is trivial, but reconstructing a BREP from the mesh is daunting.

Here're are some SIGGRAPH 2026 papers attempting BREP recovery, if you are interested. None of their automated approaches seem to work reliably, and they can only recover generic NURBS instead of analytical geometries like circles/cones/torii, etc.

https://github.com/AutodeskAILab/DualBrep https://github.com/yilinliu77/Brepler https://rilpraa0110.github.io/Img2CADSeq/

YuechenLi··on Vibe coded browser ports of Halo, The Simpsons: Hit And Run, GTA work well
What I'm interested in is their performance, since I would assume that they are running in WebAssembly from reconstructed C/C++ code decompiled from binary, what would be the overhead on that compared to running on native? And how does running on WebGPU compared to running with native through DirectX/OpenGL?
YuechenLi··on OpenSCAD the Programmers Solid 3D CAD Modeller
Near impossible to do it robustly without AI, since a mesh is a blob of triangles and vertices, it doesn't really know if something is a "face" or an "edge", and mesh STL -> BREP STEP is akin to decompilation from binary than it is a simple translation. So, the most robust approach is to get a human/LLM to reconstruct the STEP file from the STL/OBJ/glTF file with a BREP kernel.

I wish there was an easier way, but I've spent weeks during the course of the project working on and failing to solve a similar problem (SDF to BREP) and concluded finally that there just isn't an easier way to do this fully automated without AI.

You can ask your LLM to try it with one of the OCCT wrappers or with my thing, I think Aetheris is slightly better because we added more STEP diagnostic tools like ray query depth detection and SVG sectional view during the course of development.

YuechenLi··on OpenSCAD the Programmers Solid 3D CAD Modeller
Yeah, I know. I started this project earlier this year because of my own frustration with the software ecosystem and that the major CAD vendors is charging thousands of dollar to add STEP 242 support and because of proprietary lock-in and locking everything behind cloud, and was trying to see if I can accomplish this with AI.

I'm not going to pretend this is easy: I actually quit multiple times for this project because I ran into the same walls that everyone else ran to: arbitrary 3D boolean operations is HARD,(Surprisingly, I actually didn't have that much trouble with fillets/chamfers because I kept them pretty bounded) and the approach I've finally taken to solve it is pretty insane. Essentially, the final architecture is more like "LLVM for 3D objects" compiler stack than it is traditional BREP kernel. Would love to talk about the technical deep dives if people want to hear it.

Also, feel free to write UI wrappers around it, because I'm pretty bad at UI design myself.

YuechenLi··on OpenSCAD the Programmers Solid 3D CAD Modeller
To be fair, arbitrary fillets/blends on edges is a hard problem in general for Parasolid/ACIS because you are trying to mutate arbitrary topology, essentially guessing vertices/edges/faces and trying to stitch the back together.
YuechenLi··on OpenSCAD the Programmers Solid 3D CAD Modeller
Oh, since this came up, for people who like code CAD and want to try something more powerful than OpenSCAD:

https://github.com/yuechen-li-dev/Aetheris/

Not an OpenCascade wrapper, it's based off my own experimental BREP geometry kernel. So, fillets/chamfers work, booleans works fairly robustly, surfacing, sheet metal, etc all works decently, it exports STEP AP242 by default.

Haven't had time to get the AIs to write a more up to date documentation and polish the language server. Not the easiest thing to use right now, so, using it through Codex/Claude Code or CLI is probably the easiest way to get started.

Still working on the webUI currently, in case someone want to DIY the UI. Note that the WASM compilation path is still unoptimized and way slower than the RyuJIT C# compilation though.

https://github.com/yuechen-li-dev/helioscad

YuechenLi··on Port of the TypeScript compiler, checker and lsp to Rust, by LLM
Already did.

https://github.com/yuechen-li-dev/copeland

Compiles to JS, WASM via Blazor WebAssembly, C# RyuJIT and NativeAOT.

YuechenLi··on How machines learned precision
Hey, so a bit of self-promotion for some free software I built that you may be interested in.

https://github.com/yuechen-li-dev/Aetheris/

It's a code-first CAD kernel/toolkit specifically to help LLMs with CAD stuff, it's currently AI usable but not very human usable yet since I'm working on the editor UI. Get your Claude to clone it and give it a try and see if it's easier than your current workflow.

I built two 3D mechanical demos with it a couple of weeks ago that you can check out as well. https://aetheris-difference-engine-showcase.yuechenli.worker... https://aetheris-editable-v8.yuechenli.workers.dev/

YuechenLi··on Why Common Lisp is now the best programming language
Gonum is probably what you are looking for, it should have most of the optimized linear algebra stuff you need.

https://github.com/gonum/gonum

For sparse, I think the best is still Intel's sparse libraries for MKL on CPU, it's just not a workload that runs well on GPU compared to dense SGEMM. You can call it via CGo.

For GPU offloading, there should be a decent amount of CUDA bindings available for Go right now, but I'm not as familiar in that front since I'm building my own GPU compute runtime in Vulkan, but it's still very much an experimental work in progress right now.

YuechenLi··on Why Common Lisp is now the best programming language
Unless you are doing very low level C++ manual memory optimization, I would recommend using Go for both: it's on the same scale of magnitude of speed as C/C++/Fortran but the compile time is crazy fast that prototyping in a high-level scripting language like Python really isn't that necessary.

You also get very easy parallelism in Goroutines, excellent ecosystem, and one of the best performance profilers in any programming language, pprof.

YuechenLi··on Beating the compiler (2024)
Compiler isn't really difficult in the way that many think it is, because it really isn't that difficult to write a basic C compiler for example, and writing a parser is pretty mechanical that there are a multitude of parser generators. The difficult part is that writing an optimized compiler is much more difficult than writing a correct compiler, and certain language features, like generics, closure, and async, propagates and touch every part of the language that the complexity grows exponentially, and it's really hard to balance performance, compile speed, and correctness against miscompiles.

You can kinda see that in the many "compile TypeScript to native via LLVM" projects that showed up a lot recently. From my testing, none of them could beat V8/Node JIT in the majority of cases, and most of them are generally 10x-40x slower.

But, we did have a great number of innovations in language design over the last decades that really closes the gap on how optimized a compiler can be over writing assembly directly: Rust's exhaustive match default null-less error handling and language level MIR, immutable data structures from functional languages to mainstream ones, TypeScript's compile time constraints as core part of the language, and Zig's `comptime` turning compile time metaprogramming to an integrated part of the language instead of C++ template metaprogramming.

Obviously, it's not really possible to beat hand optimized C/C++ or directly authored assembly, but I think a well-designed compiler/language can potentially beat idiomatic C/C++ in performance.

And this is speaking as someone who learned compiler design solely from having every one of his vibe-coded projects turn into either a compiler or a kernel for some reason.

YuechenLi··on Pop!_OS bans AI-generated code from much of its codebase
True. I personally use LLMs much more ambitiously to help with my own coding projects, but I've always been very disciplined about planning ahead and task breakdown so that the LLMs can get it right the first time so there won't be any need to fix the code afterwards.

Other people's open-sourced project is different though, so I tend to check/test the code myself much more rigorously when contributing to other people's repos than if it is my own projects.

YuechenLi··on Agents don't need memory, they need documentation
I thought the agents are mostly self-documenting since they usually write just as much Markdown documentation autonomously as they do code/unit tests, not sure why they would need extra tools here.
YuechenLi··on Pop!_OS bans AI-generated code from much of its codebase
Ok, this may be controversial, but LLM code tokens aren't free, and I run out of my weekly allowance pretty regularly just from doing some fairly heavy projects, so I don't understand why somebody would ever want to spend their own money to make bad PRs on purpose, and I like to assume good intentions from people unless proven otherwise, which means a near blanket ban for LLM authored code for these big open source projects just seemed a bit extreme to me, when the core issue seemed to be that review process/policy should change with the times.

For example, I was helping work on an open-source game engine earlier this year with a longstanding text rendering bug dating back to around 2021 that prevents the engine from being production ready, which the community and myself have developed extensive workaround for. So, one day I've finally said enough and got Claude to debug it. It took Claude 10 minutes to find the bug, it was 3 lines of code change in the renderer (yes, three).

So, I wrote up the regression tests, documented the bug and opened up a PR for the fix, thinking it'll get merged in like less than a week and then we can all move on. The maintainers received it fairly well on the PR, but the PR sat there for nearly 6 months, unmerged, until it finally closed from a bad squash upstream. I'm pretty sure the bug is still there too.

And as a side note, I would be ecstatic if someone wants to contribute to my Github projects with their AI.

YuechenLi··on Show HN: Open-source model routing for coding agents at Astra-level performance
I don't really mind the speed, I like watching Codex work most of the time, slower work means I have time to do corrective nudging for when the initial prompt was unclear.
YuechenLi··on Show HN: Open-source model routing for coding agents at Astra-level performance
Have you compared this to using GPT-6.1 Sol instead of GPT 6 Astra + Deepseek? From my test, 6.1 Sol is a lot more token efficient than 6 Sol while being similar to Astra in performance, and I don't really find 6 Astra to be significantly better than 6/6.1 Sol for general coding as I feel 6 Astra is only noticeably better at spatial reasoning/vision compared to 6 Sol, and 6.1 Sol really closed the gap on that front.
YuechenLi··on Gemini 4 Argon
Version 0.0.0.0 after 4 years. Their goal of "full interop with C++ while being a completely new language without any of the flaws of C++" is plain absurd.

It's DOA because Google doesn't have any idea of what Carbon should be, and to be completely honest, at least 80% of what they currently use C++ for should be rewritten Go, you know, that language developed specifically because of the issues with C++ by teams within Google.

YuechenLi··on SDF vs. MSDF vs. Slug: GPU Text Rendering
This article has some inaccurate information since MSDF atlas doesn't have to be baked statically, so the "CJK character means huge atlas" is not really an issue if you can async upload them to the atlas.(Async outline extraction is a bit harder for C libraries, so that's why the pipeline is mostly restricted to atlas upload).

The other thing is MSDF rendering is fairly cheap and can be done on the CPU quite easily without GPU shaders, the atlas generation/upload is the expensive part, but it's a one-time cost per character per font as the atlas is just a normal bitmap texture file, MSDF text have sharp edges at most zoom resolutions, and the small size text is better handled with simple CPU raster anyways.

I really failed to see significant benefit of using Slug over MSDF + raster fallback for small fonts, it's definitely more exact, but I'm not sure if the marginal resolution benefit is worth it over much more complicated GPU dependent rendering, so I'd really want to test it out myself when I have the time over taking the word of an obviously AI written article for it.

← PreviousPage 2 of 5Next →