Pythonocc-nodes-for-Ryven VS jupyter-cadquery

As a visual person (traditionally trained as a graphic artist), I've wanted this sort of thing for a long while, and I've been trying to use it for 3D.

Surprisingly, there are multiple specialized tools for this:

- https://www.blockscad3d.com --- an adaptation of Google's Blockly to OpenSCAD

- https://github.com/derkork/openscad-graph-editor --- wires and nodes, it has the advantage of exposing _all_ of OpenSCAD's commands (the above has a subset)

- https://github.com/Tanneguydv/Pythonocc-nodes-for-Ryven --- a module for using PythonOCC in Ryven --- when I finally succeeded, I found the language inscrutable, even when provided w/ quite nice examples (definitely a failing on my part, not that of the tool)

- https://github.com/graphscad/graphscad --- it took a long while for the source code for this to be made available, and for a while it had compatibility problems (why was "cube" redefined?) --- probably defunct for political reasons, it had some interesting ideas, in particular the ability to have custom icons for modules

- https://www.nodebox.net --- if memory serves I got hung up by not easily being able to do 3D, and when doing 2D having precision problems (or maybe that was Processing.org)

and I've been using these tools to make various things:

https://willadams.gitbook.io/design-into-3d/3d-project

(and maybe eventually I'll finish something)

The problem I've been running into is there doesn't seem to be an answer to the question:

"What does an algorithm look like?"

I recently had occasion to mention Herman Hesse's _The Glass Bead Game_ (also published as _Magister Ludi_) and I'll bring it up again --- what is a meaningful graphical representation of a program?

The Drakon folks argued that there should be one true path but that's not really communicative and I would note that if this was a simple thing it wouldn't be decades since I last saw a physical Flowcharting Template:

https://americanhistory.si.edu/collections/object-groups/flo...

(and it's pretty rare to even see a well-done electronic drawing of a flowchart since Visio made its splash and vanished into the bowels of Microsoft)

The main problem seems to be one of expressiveness not scaling up well, hence:

https://blueprintsfromhell.tumblr.com/

https://scriptsofanotherdimension.tumblr.com/

Presumably, one doesn't want to define modules/variables unnecessarily --- but the question becomes where is that boundary?

If you define too many, then you're back to the "wall of text" which one was trying to avoid (but wrapped up in nice boxes with some lines or shapes), and if one doesn't use them (well, look at the pretty/awful images in the links above).

Ideally, a well-coded visual program would have a pleasing aesthetic appearance which is expressive and communicates flow and function, and I've tried for that at:

https://willadams.gitbook.io/design-into-3d/programming

(though I wish that there was an easy way to export an SVG version of a program)

I believe that what is needed here is some graphical equivalent to Literate Programming: http://literateprogramming.com

Is there a nice GUI toolkit integration which would allow making a graphical application with this? I have an idea I want to try it which might be a good fit.

"What does an algorithm look like?"

I'm an intensely visual person, but have never found a visual programming system which scales well --- the problem is, past a certain level of complexity one has to use modules, which then devolves the visual representation down to just a bunch named blocks.

That said, I'm using BlockSCAD:

https://www.blockscad3d.com/community/projects/1421975

to work up designs which I'm then putting into other tools.

Looking at GraphSCAD:

http://graphscad.blogspot.com

and there's also Ryven and pythonocc which I managed to get installed:

https://ryven.org

https://github.com/Tanneguydv/Pythonocc-nodes-for-Ryven

but I'd really like to see a tool for this sort of thing which made G-code.

supports WebGL over SSH/MoSH

https://www.brow.sh/docs/introduction/ :

> The terminal client updates and renders in realtime so that, for instance, you can watch videos. It uses the UTF-8 half-block trick () to get 2 colours from every character cell, thus simulating basic graphics.

https://github.com/fathyb/carbonyl :

> Carbonyl originally started as html2svg and is now the runtime behind it.

Always wondered how brew.sh added the brew sprite there; that's real nice.

TIL that e.g. Kitty term can basically framebuffer modified Chrome?

https://github.com/chase/awrit :

> Yep, actual Chromium being rendered in your favorite terminal that supports the Kitty terminal graphics protocol.

FWIW Cloudflare has clientless Remote Browser Isolation that also splits the browser at the rendering engine.

A TUI Manim renderer would be neat. Re: Teaching math with Manim and interactive 3d: https://github.com/bernhard-42/jupyter-cadquery/issues/99

What would you add to make it easier to teach with this entirely CPU + software rendering codebase?

What prompts for learning would you suggest?

- Pixar in a Box, Wikipedia history of CG industry: https://westurner.github.io/hnlog/#comment-36265807

- "Rotate a wireframe cube or the camera perspective with just 2d pixels to paint to; And then rotate the cube about a point other than the origin, and then move the camera while the cube is rotating"

- OTOH, ManimML, Yellowbrick, and the ThreeJS Wave/Particle simulator might be neat with a slow terminal framebuffer too

What a great idea.

TIL about jupyterlab-blockly https://jupyterlab-blockly.readthedocs.io/en/latest/

https://jupyterlab-blockly.readthedocs.io/en/latest/other_ex... :

> The JupyterLab-Blockly extension is ready to be used as a base for other projects: you can register new Blocks, Toolboxes and Generators. It is a great tool for fast prototyping."

jupyter-cadquery: https://github.com/bernhard-42/jupyter-cadquery

"Generate code from GUI interactions"

CADQuery

> Couldn't you equivalently use any STL/STEP/AMF viewer?

I'm not sure. A quick feedback loop is important. With OpenSCAD and CadQuery, you write code that defines the geometry. You then want to see what the geometry looks like, and possibly debug it. For this, you generally want to be able to give certain parts a different color, or opacity, wireframe, etc.

STL is out; it has to tessellate geometry turning it into triangles. AFAIK, it only supports one object. This means a sensible wireframe is out, and so are multiple parts. AMF has similar drawbacks. STEP files might work.

Generally, my understanding is many people write OpenSCAD code in their editor of choice, and then simply save the file. When you open an existing file in OpenSCAD GUI, it monitors it for changes, and refreshes. So this is great.

That said, I misspoke a bit. CQ-Editor is definitely somewhat close to OpenSCAD. It still has a - in my view - unnecessary code editor. But the last standalone release is over a year ago, and I found it to be extremely buggy on macOS. It crashes quite often. Meanwhile, Jupyer-CadQuery [0] works great.

> Seems a good choice to me that the GUI is a separate/subordinate project. I suppose it is somewhat necessary to have it at all, easier to gain popularity if you can show screenshots and have a single app 'quickstart'.

Generally, I think this is true. My personal opinion is I can be productive with something that has a minimal set of features but is rock-solid; over something that has gobs of features but is buggy. That was my main issue with FreeCAD. Ease of installation is another big one. For all it's issues, OpenSCAD gets both of these things right.

[0] https://github.com/bernhard-42/jupyter-cadquery/

I had some success with using the pre-built image. It’s good enough if you want to play around with the example notebooks out of the box if you run the container without any volume mapping.

Yep. I currently use https://github.com/bernhard-42/jupyter-cadquery; it is a jupyter-based notebook integrating cadquery. If you can do it with OpenSCAD you can do it with cadquery, the difference being working with real CAD primitives, a richer language and more features. If you do not need some of the more advanced operators which are missing in the internal CAD engine it is a very solid choice in my opinion for parametric modelling at its peak.

Neat, you might be interested in this cadquery integration with Jupyter notebooks, https://github.com/bernhard-42/jupyter-cadquery

yes thats the one. the python version is easier to work with imho, you can set it up with jupyter-cadquery + anaconda (https://github.com/bernhard-42/jupyter-cadquery) and generate results in the browser / vscode . depending on your understanding of python it shouldnt be too difficult, you probably cant take it across directly but a lot of the default values etc should transfer. and the rest just requires looking at existing code + cadquery documentation.

One day I'll finish my keyboard using joshreve's framework, It definitely is a way better experience when doing lots of changes, especially with (https://github.com/bernhard-42/jupyter-cadquery)

customising my own version similar to dactyl tracer and I'm using joshreve's port to python ( https://github.com/joshreve/dactyl-keyboard ) with jupyter cadquery (https://github.com/bernhard-42/jupyter-cadquery), which lets you customise/generate your keyboard in the browser and view the output more easily, after which you can export straight to stl (https://imgur.com/a/HX0DLxw)