MarksEnclosureHelper VS gcodepreview

I've been effective with OpenSCAD and FreeCAD.

OpenSCAD is good for enclosures: https://github.com/sbambach/MarksEnclosureHelper

and mechanical systems: https://github.com/prusa3d/Original-Prusa-i3

Don't think of it as a programming language; that will hurt you. Think of it as a specification language. That helped me.

there should be a support group. "Show me where OpenSCAD hurt you".

I wrote this: https://github.com/sbambach/MarksEnclosureHelper

I share your pain

I did some early documentation of the Linux advanced networking capabilities when they came out in 2.2; it was widely cited for a while. I couldn't grow it effectively and others supplanted it reasonably quickly. [1]

I don't work easily with others so I tend to publish projects in hope they're useful enough for others, then never revisit or update them. My python arrays / mmap slicer module [2] got into FreeBSD ports for several years and I was told was used in some of the early dedicated media player things.

Source available that I can point to would be my OpenSCAD box script [3], which some kind soul has taken on after I left it.

These contributions are not much to compare to the value, and joy, that has been given to me by others in the form of their freely shared work; but I hope that by contributing in the same spirit that I have done my part to help improve the world, as well as sharing my joy in geeking out over stuff others may not care about.

[1] https://web.archive.org/web/20030601115204/http://www.snafu....

[2] https://web.archive.org/web/20030317074418/http://snafu.free...

[3] https://github.com/sbambach/MarksEnclosureHelper

I've been working on this sort of thing for a while.

For a Japanese spin on this see Tsugite:

http://ma-la.com/Tsugite_UIST20.pdf

which I worked through at:

https://community.carbide3d.com/t/a-study-of-joinery/28492

Traditional joints (box, dovetails, or obscure variations such as Knapp (cove and pin)) require a vertical fixture and 3 setups (at a minimum) --- cut parts to length and machine internal features, mount four board and cut joints in 2 corners, flip boards (with correct orientation) and cut other two corners.

Rabbet joints are simpler --- so simple that they were covered in a video as "The Simple Box":

https://www.youtube.com/watch?v=V93xDM3lXsM

(ob. discl., I work for Carbide 3D)

There have been a number of programs developed for joinery. A current commercial option is:

http://www.g-forcecnc.com/jointcam.html

(but it requires a vertical fixture)

One commercial option became freely available:

https://fabrikisto.com/tailmaker-software/

and ingeniously has an option where a 30 degree V endmill is used, but to cut boards held at a 15 degree angle, affording a 90 degree cut with a great deal of control and flexibility --- this can multiply setups to 9.

A variation I've been experimenting with is full-blind box joints:

https://community.carbide3d.com/t/full-blind-box-joints-in-c...

They're reasonably easily drawn up, though they do have some rather specific tooling requirements (a narrow 90 degree V endmill, a square tool of that or smaller diameter, and to make things easier, a large V endmill)

One test project was so tight that after putting it together for a dry-fit before gluing I was unable to get it apart:

https://cutrocket.com/p/63781eaf9822f/

I've been working on a programming system to make this sort of thing a bit easier:

https://github.com/WillAdams/gcodepreview

and have some sketched out joints which I've not been able to make using existing CAM tools which I hope I'll be able to do using this system (if anyone could recommend books on conic sections, I'd be grateful --- that's where I got bogged down last time).

While I certainly appreciate the virtues of a Domain Specific Language, and that OpenSCAD has been wildly successful because of its limitations, the limitations are downright infuriating at times.

An interesting potential alternative (which hopefully won't result in a fork) is adding Python:

https://pythonscad.org/

which I've had some success with:

https://github.com/WillAdams/gcodepreview

ImplicitCAD is interesting --- and the (new?) ability to open files from GitHub is _amazing_ (OpenSCAD recently gained that same facility, _and_ it supports the customizer: https://seasick.github.io/openscad-web-gui/?https://raw.gith... ), but it's a heavy lift given the need to work out how to edit files, preview them, and so forth.

Do you have a need to?

Do you have a project which might be able to make use of this? What sort of work do you do?

I am bookmarking this for re-reading later because I hope it will help me to understand how to implement Bézier curves in a tool I've been working on for controlling a CNC machine/creating files for cutting on a CNC:

https://github.com/WillAdams/gcodepreview

(but first I have to get arcs working)

Interesting.

I've long been frustrated by traditional CAD/CAM, so finally worked up:

https://github.com/WillAdams/gcodepreview

which allows me to use:

http://pythonscad.org/

and:

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

to create joinery:

https://forum.makerforums.info/t/openscad-and-python-looking...

which would otherwise be tedious to draw up:

https://community.carbide3d.com/t/creating-drawers/19475/26

The problem here is that a fundamental question has not been answered, and as far as I can tell, has not been addressed by any of these visual environments:

What does an algorithm look like?

Herman Hesse alluded to this in his novel _The Glass Bead Game_, but despite decades of discussion and work, no one has made a convincing pysical representation of that system.

I love the concept, and have made some moderately complex attempts, e.g.,:

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

https://github.com/WillAdams/gcodepreview

it always devolves to screen size being out-paced by problem complexity --- one gets something of an inkling of this at:

https://scriptsofanotherdimension.tumblr.com/

Alternately, one can just break a project down into modules, but then the top-level view becomes the wall of text representation (albeit w/ nice lines or captured into pretty boxes) which one is ostensibly trying to escape.

I'd love to see someone succeed in this, and I've been using:

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

quite a bit, and put a bit of money towards:

http://nodezator.com/

or perhaps Solvespace --- certainly FreeCAD, and if you're inclined to do programming, OpenSCAD --- see: https://github.com/WillAdams/gcodepreview for an approach which uses RapCAD