openscad-graph-editor VS ezmdpage

Do you want BRL-CAD?

https://brlcad.org/

(what you describe sounds a bit like my limited understanding of its UI)

As noted, the usual suspects are LibreCAD, FreeCAD, or if you want to go completely programmatic, OpenSCAD. For the latter, if you already know Python, you might want to consider (Open)PythonSCAD:

https://pythonscad.org/

If you want a graphical front-end using nodes and wires (to reduce syntax errors) there is:

https://github.com/derkork/openscad-graph-editor

You might want to consider a traditional vector drawing program such as Inkscape or Cenon.

Early on in Microsoft's Windows for Pen Computing and Tablet PC efforts there were some very cool programs exactly suited to this sort of thing such as Saltire Sketchright:

https://www.nonvi.com/sm/sr.html

I'd love to see the features from Sketchright in a tool such as:

https://rnote.flxzt.net/

or Inkscape.

Finishing up yet another re-write of my current project:

https://github.com/WillAdams/gcodepreview

which I hope to then wrap up in a nice front-end using:

https://github.com/derkork/openscad-graph-editor

(or maybe some other tool --- is there a stand-alone, desktop version of Blockly which is extensible?)

Hopefully I'll also figure out how to write up a LaTeX package for the Literate Programming technique used and maybe a _TUGboat_ article.

Excellent points.

(much of the below has been posted in other discussions here, my apologies to folks who are seeing it for the _n_th time)

This is a sort of tool I've believed in/wanted for a long while (and I've been funding the author and chatting with him on Discord and via e-mail), but there seem to be a few fundamental issues which good answers need to be found for:

>What does an algorithm look like?

Can such visual tools be expressive enough to justify the effort?

They seem to work well for problems which can be expressed as one screen of diagram --- and while making modules would seem an easy way to increase the complexity, this goes against the initial mode of expression and if overdone, results in the wall-of-text one is trying to escape from, just dressed up in colored boxes and lines. Once one starts to scroll, or can't see the entire flow at a glance, things get complicated.

And of course, there are collections such as:

https://blueprintsfromhell.tumblr.com/

https://scriptsofanotherdimension.tumblr.com/

which might be used as arguments against.

I've been using:

https://www.blockscad3d.com/editor/

but it doesn't support all of OpenSCAD (and has some annoying bugs in what it does try to implement) and also funded:

https://github.com/derkork/openscad-graph-editor

but it has problems with a stylus (I have to leave the Windows Settings app open to toggle stylus behaviour which is enough friction that I don't use it as much as I would otherwise).

Hopefully the author will pop in and share a bit.

Quite a different problemspace, but there is:

https://github.com/derkork/openscad-graph-editor

which allows programmatic 3D modeling using nodes/wires. It exposes _all_ of OpenSCAD (last I checked) and is quite extensible (I use it to control a Python-enabled version of OpenSCAD https://pythonscad.org/ in an effort to make DXFs and G-code: https://github.com/WillAdams/gcodepreview )

Why did it have to be pixelated in appearance? It would be far more attractive as anti-aliased vector lines and type.

The red highlighting reminds me of electricity in the classic circuit problem game _Rocky's Boots_ on the Apple ][.

As I've posted in similar discussions: https://news.ycombinator.com/item?id=42051536

The problem here, as always is that there isn't an agreed-upon answer for the question:

>What does an algorithm look like?

The problem is expressiveness of such a diagram is bounded by the size of a screen or a sheet of paper, and once one starts to scroll, or can't see the entire flow at a glance, things get complicated.

The node/wire programming folks have this a bit rougher to the point that there are sites such as:

https://blueprintsfromhell.tumblr.com/

https://scriptsofanotherdimension.tumblr.com/

I prefer to work visually, but not sure if that's actually valid --- unfortunately https://www.blockscad3d.com/editor/ doesn't support all of OpenSCAD and https://github.com/derkork/openscad-graph-editor has problems with a stylus (I have to leave the Windows Settings app open to toggle stylus behaviour which is enough friction that I don't use it as much as I would otherwise).

There are promising tools though: https://nodezator.com/ and https://ryven.org/ are very cool.

Parallel track:

- MacBASIC: Mac GUI programming w/o Pascal or C https://www.folklore.org/MacBasic.html (which is something I'll never forgive Bill Gates for)

- HyperCARD: It was magic to get into Developer mode and to create stacks --- it's unfortunate that Asymetrix Toolbook didn't get further, and a shame that Runtime Revolution which became Livecode reneged on their opensource effort --- hopefully someone will make good on that: https://openxtalk.org/

Unfortunately, I never got anywhere w/ Interfacebuilder.app or Objective-C....

- OpenSCAD: Make 3D things w/o having to use a full-fledged CAD program

- BlockSCAD: Make 3D things w/o typing: https://www.blockscad3d.com/editor/ (though to be fair, https://github.com/derkork/openscad-graph-editor also allows that)

- PythonSCAD: variables and file I/O for OpenSCAD (though to be fair, RapCAD had the latter, it was just hard to use it w/o traditional variables) https://pythonscad.org/

Still working through a re-write of my OpenSCAD library in Python: https://github.com/WillAdams/gcodepreview and am hopeful that a tool like to https://nodezator.com/ will make that graphically accessible.

Nice! Great to see (Open)PythonSCAD listed! (I know this sort of thing is hard to keep up with --- I was trying for a long while on the old Shapeoko wiki (see link elsethread)).

A tool I'd suggest considering adding is:

https://github.com/derkork/openscad-graph-editor

(I guess it would fall under "GUI")

I'd give a lot to have a graphical development environment which:

- allowed drawing a user interface as naturally as I used to use Altsys Virtuoso (or Macromedia Freehand which I moved to when my Cube stopped working)

- allowed programming the UI as naturally as HyperCard (and to a lesser extent Lisp) "clicked" for me

- was as visual as Google's Blockly (which as BlockSCAD: https://www.blockscad3d.com/editor/ I've used a fair bit)

- exposed variables in a mechanism like to OpenSCAD's Customizer: https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Customize...

Currently plugging away with OpenSCAD Graph Editor: https://github.com/derkork/openscad-graph-editor but hoping that: http://nodezator.com/ will become a viable option (still a bit bummed that I rolled and crashed w/ https://ryven.org/ though in retrospect, maybe I should try to tie that latter in to: https://pythonscad.org/ )

One of the things I recommend to the startups I advise is to include documentation within the repository. I always try to have a /doc directory which includes Markdown (I like using [1] self rendering markdown pages) and MermaidJS (For which I also created a dumb self rendering script [2]).

That way Merge Requests can be blocked for lack of documentation, or lack of documentation update.

MermaidJS have been a godsend for documentation.

[1] https://github.com/jcbhmr/ezmdpage