antimony

> Can anyone explain where this blob of "assembly language" comes from? Assembly language is definitely the right analogy: it's a low-level target generated by higher-level tools. In this case, the expression came from a Python script calling this text(...) function: https://github.com/mkeeter/antimony/blob/f6a56dd7/py/fab/sha... The font is hand-built from geometric primitives (rectangles, circles, etc) and CSG operations (union, intersection, difference) > What is considered an acceptable preprocessing or transformation? I'm looking for interesting ideas, and to mine the depths of PLs / compiler / interpreter / runtime research. Just returning a fixed image isn't particularly interesting, but (for example) I just updated the site with a compile-to-CUDA example that shows off the brute force power of a modern GPU.

For anyone interested in this, I would also recommend checking out the [antimony project](https://github.com/mkeeter/antimony). It's a parametric modeling program, but you can also pretty easily produce new scripts for its visual nodes.

> Lots of potential, but IMO not really usable for real world work. What about Antimony and VisualScriptCAD?[0,1] [0] https://github.com/mkeeter/antimony [1] https://github.com/kovacsv/VisualScriptCAD

Just a quick diff between your list and mine, apologies if I missed them or if there is a reason to exclude these: - https://github.com/nickc92/ViewSCAD - Matt Keeter's stuff (listed here https://www.mattkeeter.com/projects/, including https://github.com/mkeeter/antimony and https://www.mattkeeter.com/projects/ao/, though I see you have libfive) - https://solvespace.com/index.pl - https://mirmik.github.io/zencad/en/ - https://github.com/fogleman/sdf This is from a list entitled "migrate away from OpenSCAD", but somehow I can never manage to do that... Thanks for this site!

JS doesn't have first-class environments, so you can't have the same safety guarantees. Added with its weak typing... You could instruct JS to calculate anything. Visual Programming might possibly be useful for end users, but in most areas, there are better approaches. Serving limited environments to users is useful in at least these situations: * nREPL * Database APIs (ala firebase) * Mathematical APIs (ala Mathematica) Some of these I've needed in production, such as more precise calculations for statistics. (FloNum integrations into pre-existing applications). My main point was, LISP is unconstrained, but still gives safety to the programmer. A simple example of a first class environment: (eval (read (current-input-port)) (let ((add (lambda args (apply + args))) (null-environment))) The only function exposed

I assume you're talking about Antimony. Its graph UI is done in Qt, using the QGraphicsView framework. That section of the code is at https://github.com/mkeeter/antimony/tree/develop/app/canvas

Antimony [1] is stable and user-friendly. You can get started without knowing about the underpinnings, just by connecting predefined shape nodes into a graph – basic modeling is possible with just the mouse, as shapes can define handles in the UI. Using Python for scripts is also a bit more accessible than Scheme. The downside is that hacking raw shapes is less pleasant, because they're defined as strings implementing a DSL. Developing on Antimony is also slower – much of the code is UI and glue to attach the geometry + graph engines. Ao is more experimental and unstable. It's much lower-impedance for folks that want to work directly with f-reps, but doesn't have a click-and-drag UI with which to get started. The geometry kernel is also newer than Antimony's, and has slightly better performance. From a development perspective, I ca

links: http://mattkeeter.com/projects/antimony and http://github.com/mkeeter/antimony Python scripting too.

Antimony does general implicit surfaces, not just CSG with Platonic primitives. So it has operations like "morph" https://github.com/mkeeter/antimony/blob/develop/py/fab/shap..., "blend" (for fillets!), and "shell", and it seems like it would be pretty easy to add metaballs, although Matt doesn't seem to have done them.

This is a really great question. I don’t know the answer yet. I struggle with this problem every day when I design things in OpenSCAD, because OpenSCAD doesn't give your parametric model access to the results of the modeling operations in any way (!!) I think that Antimony kind of suffers from the same problem, but because it's using distance fields rather than plain CSG, it does have a “blend” operation (https://github.com/mkeeter/antimony/blob/develop/py/fab/shap...) that attempts to fillet the union of two shapes. Now, Antimony has inversion (complement, more or less), and set A \ B is just A ∩ B', which by De Morgan's Laws is equivalent to (A' ∪ B)'. So what happens if you attempt to approximate a filleted A \ B with invert(blend(invert(A), B))? I don’t know. But damn, I’m sure tempted to try it! Of course, even if that works, t

> It does not allow commercial use It does, but I agree that the author should choose an established license instead of trying to make one up by putting 3 lines in the README: https://github.com/mkeeter/antimony

Compared to AutoCad/Inventor, cost and licensing are two huge differences. Antimony is open source: https://github.com/mkeeter/antimony/blob/develop/README.md