jupyter-cadquery VS dactyl-keyboard

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)

For a curved keyboard without a 3D printer and without a laser cutter... well, I've imagined something like origami, but never accomplished it.

My Dactyl Manuform is at https://github.com/jaredjennings/dactyl-keyboard/tree/tshort-plus-jared, including a shell that goes over top for protection in transit.

A common complaint with both the Ergodox and the original Dactyl is that it's only really easy to reach the innermost thumb key. On my tshort Dactyl Manuform I can only easily reach the innermost two thumb keys. There are many thumb layout variations, one of which you have pictured, as well as wider Dactyl variations.

For flat keyboards: I haven't seen anyone mention https://jhelvy.shinyapps.io/splitkbcompare/ yet, so I will. With a flat keyboard you can print out the layout on a sheet of paper to initially check it out. For curved keyboards I am not aware of a similar way to cheaply try them out.

If yours is the original tshort version, like mine, grab an STL! If you have modifications (e.g. different thumb cluster, changes to parameters, different ProMicro mounting, TRRS plugs), you'll need to muck about in the source to get it to generate a case for yours.

(I still want to be able to make paper models someday, though.)

In my design (don't print it just now, I experimented with the key placement and it is wrong and will hurt you), I added web-logs, which are like web-posts, but lying down parallel to the plane of the key, and used them to round off the sharp corners. Belatedly I realize I should have called them web-beams instead. Oh well.

you can go from the other end of the problem, (1) git clone https://github.com/jaredjennings/dactyl-keyboard jdactyl; (2) cd jdactyl; (3) git checkout tshort-plus-jared; (4) lein repl; (5) (load-file "src/dactyl_keyboard/dactyl.clj"). but this will get you a tshort dactyl manuform.

I made one, but I've never gone to the effort to post a picture of it. It's a shell that goes over each half. https://github.com/jaredjennings/dactyl-keyboard/commit/cd43dfd01e5847cc262664da073d67bb9cae5617.

That's why I mostly want to give people the benefit of the doubt about whether they should share their designs. Partly to try to avoid undercutting entrepreneurs, I've held off trying to develop PCBs for my Dactyl fork, since before this controversy came to light.