r/OpenPythonSCAD • • Aug 29 '26

A Japanese teacher is publishing near-daily PythonSCAD lessons — and it's a small masterclass in teaching CAD-as-code

18 Upvotes

If you want to see what it looks like when someone actually teaches parametric CAD from first principles, take a look at yokamak on Zenn (a Japanese dev-blogging platform, similar to dev.to): zenn.dev/yokamak — he also mirrors most posts on Qiita.

Everything is in Japanese, but don't let that stop you — Chrome's built-in page translator does a genuinely good job turning it into English (or whatever your native language is) on the fly, code comments included. Read that way, the series basically works as a free, ready-made PythonSCAD tutorial, not just an interesting blog to skim.

Yokamak teaches at a technical college in Hitoyoshi (Kyushu) and at a Tokyo metropolitan school's information-technology department, and he's been publishing an almost-daily series called 「高校生のためのPythonSCAD練習帳」 — roughly "A PythonSCAD practice notebook for high schoolers." It's aimed at students who are new to both programming and CAD, and it's now well past a dozen installments.

What makes it worth a look even if you don't read Japanese (the code and diagrams carry a lot of it on their own, and machine translation handles the rest fine):

  • He starts from real first principles. One early lesson has students compute a triangle's area using the shoelace formula, print the result to the console, and also render the triangle in PythonSCAD's 3D view — so the math and the geometry validate each other.

  • He teaches the traps, not just the happy path. A follow-up lesson deliberately orders polygon vertices wrong, shows the resulting self-intersecting "bowtie" shape, and walks through why vertex winding order matters before generalizing to an n-gon area function with a for loop.

  • He shows real debugging, errors included. One post pastes an actual TypeError traceback from a nested-list indexing bug and works through the fix live, rather than presenting only clean, working code.

  • He connects PythonSCAD to other tools. There's a lesson exporting 2D polygon data out of Metasequoia (a Japanese 3D modeler) via its scripting API, reformatting it into PythonSCAD-ready code, and then extruding/rotating the imported profile — a nice bridge between mouse-driven modeling and code-driven modeling.

  • He explores the object model itself, e.g. digging into PythonSCAD's documented "dynamic attributes" to pull .points and .size back off an already-built polygon object, rather than just calling functions and moving on.

  • The comments are genuinely useful. On the vertex-ordering lesson, a PythonSCAD contributor chimed in suggesting the reader try 3-tuple points [x, y, r] for per-vertex rounding, and polylines with 3D coordinates for annotation — and yokamak turned around and posted a follow-up experiment using exactly that within a day.

Beyond this series he's also been poking at build123d as a natural next step after PythonSCAD (CSG-style "Algebra mode" first, since it's a near 1:1 mental model transfer, with Builder-mode sketch-driven modeling introduced later as a bridge to commercial CAD tools), and separately uses Pyxel to teach high-school math graphing in Python.

It's a nice example of someone documenting a teaching curriculum in public, in near-real-time, mistakes and all — worth a follow if you're interested in PythonSCAD, OpenSCAD, or CAD/programming education generally.

🔗 Series index / articles: https://zenn.dev/yokamak 🔗 Mirror on Qiita: https://qiita.com/yokamak 🔗 PythonSCAD: https://www.pythonscad.org/


r/OpenPythonSCAD • • Jun 03 '26

PythonSCAD v1.0.0 "impletio" released

18 Upvotes

Hi everyone,

We are thrilled to announce PythonSCAD v1.0.0 — our biggest release so far. This version marks a milestone: PythonSCAD has grown from a promising OpenSCAD fork with Python support into a mature, first-class tool for script-based 3D modeling. We have landed 83 pull requests since v0.20.0, covering everything from fundamental API architecture to a real IPython shell, native vector math, a completely refreshed Windows experience, full rebranding, and dozens of bug fixes.

API

We have again worked hard on improving what you can do in your design code.

Polyline improvements

Polylines now participate correctly in difference() and intersection() operations (PR #572), and polyline preview has been improved (PR #575). After this fix, PythonSCAD is a great choice to "select" given areas from given imported 2D files and place correctly for an upcoming laser-cut. Polylines also work in 3D world, where they are a great choice to annotate direction vectors or even dimension arrows.

solid.c color property

A new read-only .c property on solid objects (PR #562) exposes the RGBA color of the root color() wrapper as a (r, g, b, a) tuple — useful for reading back colors from a colored solid in Python code.

Native vector operations

Solid geometry objects now support arithmetic operators directly (PR #588): addition (+), subtraction (-), scaling (*), dot product, and cross product. This makes geometric expressions in Python feel natural without needing to call helper functions for every operation. Any Vector returned by PythonSCAD supports these calculations. For others simply use the vector() function.

from pythonscad import *
c=cube(10,center=True)
vec1=c.position
vec2=vector(4,5,6)
print(vec1)
print(vec2)
print(vec1+vec2)
print(vec1.norm()) # vector size

New + operator for union (#658)

We've added a new + operator which allows you to union objects:

from pythonscad import *
show(cube(10) + sphere(5))

It is an alias for the already existing | operator. You can continue to use - for difference and % for minkowski as before.

MultiToolExporter

A new MultiToolExporter helper in the pythonscad module (PR #585) makes it straightforward to split a single model into multiple per-tool or per-color output files — a common need for multi-material or laser-cut workflows:

from pythonscad import *

background = cube([200, 100, 1]).color("blue")
star       = cylinder(r=20, h=2, fn=5).translate([100, 50, -0.5]).color("red")

exporter = MultiToolExporter("out/flag-", ".stl", mkdir=True)
exporter.append(("blue", background))  # blue part, minus the star area
exporter.append(("red",  star))        # red part (later entries win)
exporter.export()
# writes out/flag-blue.stl and out/flag-red.stl

# Or: one 3MF file with two named parts
export(dict(exporter.parts()), "flag.3mf")

Later entries "win" over earlier ones, so overlapping volume is assigned to exactly one output file.

Dynamic oversampling (new)

A new dynamic oversampling mode (PR #554) basically remeshes existing solids to a finer grid. Main purpose so far is to bake any texture onto the shape. The second parameter is the target grid to lay the texture on. Many different projection modes are possible, whereas triplanar might be the best starting point.

from pythonscad import *

model=cube([10,4,4],center=True) | cube([4,10,4], center=True) | cylinder(r=3,h=5,fn=20)


textured = oversample(
    model, 0.1, texture="../image/smiley.png", projection="triplanar",
    texturewidth=2, textureheight=2, texturedepth=0.2
)
textured.show()

Clean Python module layout: openscad / pythonscad / _openscad (new, breaking)

v1.0.0 restructures the Python surface into three distinct modules (PR #579):

  • _openscad — the C extension (renamed from openscad). Rarely imported directly; it is the engine room.

  • openscad — a pure-Python overlay that re-exports _openscad 1:1. The home for OpenSCAD-compatible additions and future per-symbol deprecation notices.

  • pythonscad — a pure-Python overlay that re-exports openscad 1:1. The home for PythonSCAD-only features.

The drop-in guarantee: openscad.cube is _openscad.cube and pythonscad.cube is openscad.cube, so switching between from openscad import * and from pythonscad import * requires no other code change. All three modules are shipped in the pip wheel, each with a PEP 561 type-stub package (-stubs/) so IDEs can provide autocompletion for whichever import style you prefer.

New scripts and templates use from pythonscad import *. Existing designs using from openscad import * continue to work unmodified.

This is an internal change, but it is very important for the future of the project, as it allows us to add new Python features written in pure Python without needing to implement anything with the more cumbersome Python C API (like the MultiToolExporter mentioned above).

Note: As some new features which are exclusive to PythonSCAD will only be added to the pythonscad package, we recommend everyone to switch to from pythonscad import *.

Note: The C extension rename from openscad to _openscad is a breaking change for code that imported openscad directly as a C extension (not via the overlay). Any code using from openscad import * is unaffected though.

UI improvements

Inline Python trust bar

The blocking modal trust dialog that appeared before you could even read a Python file has been replaced with a non-intrusive inline bar above the editor (PR #667). You can now open, scroll, and review a file before deciding to trust it. The bar appears at the top of the editor (pushing the text down, never overlapping it), Preview and Render are disabled until trust is granted, and once you click "Trust Design" the customizer populates immediately.

External-editor workflows are smoother too: if you edit a trusted file in VS Code while PythonSCAD is open, it auto-trusts on reload without asking again.

Bugfixes and improvements to session management

A feature we introduced in the last release is session management. You might have seen it in programs like Visual Studio Code or Notepad++ already. When session management is enabled, PythonSCAD will automatically save all open tabs with all their changes to a session file when you close the program. When you start PythonSCAD again, it will automatically restore all tabs with all their unsaved changes. So no more annoying "Do you want to save Untitled.py?" popups when closing the program. No more "PythonSCAD is preventing Windows from shutting down."

You close the program and when you come back everything is just as you left it.

On top of that this also adds periodic autosave. So in case PythonSCAD crashes, or during a power failure, you won't lose more than a minute of work.

Note: In v0.20.0 where session management was first introduced, it was disabled by default. As it is now stable enough, we enabled it by default in v1.0.0. But this means if you've ever used v0.20.0 you need to enable session management in "Edit > Preferences > Advanced > User Interface".

Real IPython shell (--ipython) and basic REPL (--repl) (new)

pythonscad --ipython now launches a genuine IPython interactive shell — the same rich In [N]: prompt, tab completion, history, and magic commands you get from the ipython command itself (PR #600). IPython is bundled inside the AppImage, macOS .app, and Windows installer so it is available out of the box without any extra pip install.

$ pythonscad --ipython
In [1]: from pythonscad import *
In [2]: cube(10).color("Tomato")

For a lighter, dependency-free prompt, the new --repl flag opens the basic embedded Python REPL. Distro packages (.deb, .rpm) declare python3-ipython as a recommended dependency rather than bundling it, keeping the package footprint small.

Title bar shows full path (new)

The main window title bar now displays the absolute file path of the open design (PR #576), so it's always clear exactly which file you're editing when working across multiple directories.

More PythonSCAD rebrand (new)

With v1.0.0, PythonSCAD is more thoroughly rebranded throughout (PRs #661, #669, #672, #676, #684, #686): About dialog, application metadata, desktop file IDs, localization strings, homepage URLs, and the macOS dock icon all show PythonSCAD consistently. Hopefully there are no more leftover "OpenSCAD" references in unexpected places.

Platform support

New Linux platform support

Pre-built packages are now available for Fedora 44 and Ubuntu 26.04 LTS (PR #624).

Windows improvements

v1.0.0 brings a significantly better Windows experience:

  • Per-user installer with on-demand UAC ([PR

    696](https://github.com/pythonscad/pythonscad/pull/696)): The installer no

    longer requires administrator rights by default. A "Just for me / For all users" page lets you choose. UAC elevation only fires if you explicitly request an all-users install — a UAC shield icon on the Next button signals when elevation will be requested.

  • Code-signed Windows installer ([PR

    703](https://github.com/pythonscad/pythonscad/pull/703)): The Windows

    installer is now signed with a Certum code-signing certificate (CN=Open Source Developer Michael Postmann), so Windows SmartScreen will recognize it as coming from a known publisher and will no longer show the "Windows protected your PC" error message.

  • MSIX package ([PR

    638](https://github.com/pythonscad/pythonscad/pull/638)): A Windows

    Store–style .msix package is now produced alongside the traditional NSIS installer and ZIP archive. The MSIX Package is signed as well. For the time being both the installer and the MSIX package will be supported.

PythonSCAD is now available on PyPI

PythonSCAD v1.0.0 is now available on PyPI, so you can install it with pip install pythonscad and get the latest version. This version will not have a GUI, but combined with the export() function, you can have self-contained projects where you just deliver your Python design file combined with a requirements.txt file that lists pythonscad as a dependency.

Users could then create a Python virtual environment:

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -r requirements.txt
python design.py

Which would render your design into an output file. Great for automation.

Note: Be aware, though, that in this first iteration we do not yet provide pre-built wheels. This means that the pip install command will likely take 20+ minutes (depending on your machine of course). Also you're going to need a lot of build-dependencies installed on your system. The easiest way is to clone the repository and then run scripts/get-dependencies.py which will install all required dependencies for you. We are working on providing pre-built wheels for one of the next releases, which will make installation much faster and easier.

Reliability and bug fixes

v1.0.0 includes a large number of stability and correctness fixes across the board:

  • Resize now behaves consistently across all cases (#557).

  • Fillet calculation corrected (#625).

  • SVG import: title handling and osimport:stroke parameter fixed (#570, #577).

  • Session restore now persists per-window geometry (#627) and the macOS IPC socket name is shortened to fit system limits (#640).

  • Console output from compile and parse operations is now routed correctly to the console widget (#643).

  • Python binding robustness: multiple memory leaks, UB, and error-handling gaps resolved (#603, #608, #610, #611, #619).

  • CSG tree: missing CONCAT case in switch handled (#653).

  • Startup crash and double file dialog from the welcome screen fixed (#695).

  • Fontconfig 2.18.0 app-font scoring regression worked around (#691).

  • macOS: deprecated kUTTypePNG API replaced, dock icon corrected, theme mismatch in preferences fixed (#651, #675).

  • --define on the command line now works during animation too (#699).

  • Welcome dialog New button restored when Python support is disabled (#637).

Upstream changes

We have merged all changes from OpenSCAD into our codebase to bring in the latest bug fixes and enhancements from the upstream project (#559, #583).

Downloads

Pre-built packages are available for Linux (AppImage, .deb, .rpm), macOS (DMG), and Windows (installer, ZIP, and MSIX):

https://pythonscad.org/downloads/

As always, we would love to hear from you — feedback and bug reports are very welcome!


r/OpenPythonSCAD • • Aug 08 '26

Package management, Gridfinity and PythonSCAD

15 Upvotes

Without much fanfare we recently published PythonSCAD to PyPI. It was buried somewhere in a release announcement.

However, I wanted to showcase how amazing this is and how easy this makes it to use PythonSCAD in your own projects.

I've ported the awesome Gridfinity Rebuilt in OpenSCAD project by GitHub User kennetek (which is an implementation of the great original Gridfinity specification published by Zack Friedmann) over to PythonSCAD.

It is available on GitHub and itself published to PyPI as well.

So now you can just create local Python venv, install the library with pip and use it:

nomike@scrooge:/tmp/psgfd$ python3 -m venv .venv && source .venv/bin/activate

(.venv) nomike@scrooge:/tmp/psgfd$ pip install pythonscad-gridfinity
...

(.venv) nomike@scrooge:/tmp/psgfd$ cat simple_bin.py 
from pythonscad import *
from gridfinity import GridfinityBaseplate, GridfinityBin, HoleOptions

bp = GridfinityBaseplate(2, 2, style="weighted",
                         hole_options=HoleOptions(magnet_hole=True))
export(bp.render().color("SteelBlue"), "baseplate.stl")

(.venv) nomike@scrooge:/tmp/psgfd$ python3 simple_bin.py 

(.venv) nomike@scrooge:/tmp/psgfd$ ls -lah baseplate.stl 
-rw-rw-r-- 1 nomike nomike 809K Aug  9 00:28 baseplate.stl

As seen in pythonscad-gridfinity you can use a section in pyproject.toml to depend on pythonscad, but you can also just put it into your requirements.txt, use uv or whatever tickles your fancy.

This is the kind of package management which OpenSCAD tried to get for ages. But as we use Python as a basis, we don't have to invent it. It already exists in the form of pip, PyPI and the whole Python ecosystem.

This is very exciting and I'm already curious what awesome things you peeps are going to come up with.

Link your projects in the comments or post them in a new thread and share your creations with others.


r/OpenPythonSCAD • • 28d ago

Coming soon to PythonSCAD: drag your model, and your code follows

10 Upvotes

Hi everyone,

here's a preview of a feature that is coming to PythonSCAD soon: interactive dragging that writes back into your Python code.

In the video, I build a little desk lamp in Python and then shape it with the mouse. Hold Ctrl and drag a vertex. The parameter behind it changes live in the editor, and when you let go, the whole model is rebuilt from the new value.

How it works

Wrap any number you want to be draggable in marked() (or just write it as a string):

ARM1 = "130"          # lower arm length
J1   = "-20"          # joint angle

arm = cube([10, 10, ARM1], center="||[")
arm = arm.rotate([0, J1, 0])

Drag the top of the arm and ARM1 changes. Drag the arm sideways and J1 changes. Since the value lives in a variable, the definition at the top of the file is updated, and everything that depends on it moves along after you release the mouse.

What you can drag

  • cube: each size component, or the scalar size

  • sphere: r / d

  • cylinder: h, r, r1, r2, d, d1, d2, and even angle

  • polyhedron: individual vertices, only along the coordinates you marked

  • translate, scale, rotate, including nested rotations like an elbow joint

It's not just "move the point in screen space"

The grabbed point follows the path it can actually take. A rotation moves it along its real circle, so you can swing an arm smoothly, even past 180° and around several times. A single marked axis slides along a line, and two axes stay in their plane. Values snap to sensible steps (0.1 mm, 1°), so your code stays clean.

Function style (translate(obj, v)), method style (obj.translate(v)) and variables defined elsewhere in the file all work.

A demonstration of the feature in action can be found here:

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

Feedback and ideas welcome! What would you want to drag next?


r/OpenPythonSCAD • • Jul 16 '26

PythonSCAD v1.1.2 "Prominentio" released

9 Upvotes

You can find this announcement also on our website.

Hi everyone,

We are happy to announce PythonSCAD v1.1.2 "Prominentio" (*).

With so much going on since the last release, it's hard to decide what to write about first.

This release adds a number of nice features to the Python API like the new organic() mesh feature, which connects a cloud of points into a smooth, watertight organic surface. There are improvements to the MultiToolExporter (which we introduced in the previous release), which now allows exporting multiple objects into a single .3mf file. This is great for multi-tool printing! .mesh() now has an option to also export color information.

We are now publishing pre-built binary wheels to PyPI, which means you can now just do pip install pythonscad or add pythonscad to your project's dependencies and in mere seconds use it directly in your projects.

One new feature we're particularly excited about is that you can now try PythonSCAD in your browser. This is powered by a Python-enabled WebAssembly version, which you can integrate into your own web-based projects as well.

Last but not least we've done a ton of behind-the-scenes fixes, improvements to our website and build system. The Windows installer has been massively overhauled and now supports installing PythonSCAD without requiring administrative privileges.

(*) We tried releasing v1.1.0 and v1.1.1 within the last few days, but since then learned that the new Python wheel builds were failing and we needed a few days to address that issue. Thus we decided to pull those version from the shelves again so we can address that issue and release it with v1.1.2.

Release name

As you might have noticed, we started to introduce release code names for major and minor releases with the previous release (v1.0.0). We use those during development as the next version number is not always clear due to semantic versioning.

As a general theme for that, we chose terms in relation to 3D printing but loosely or directly translated to Latin.

v1.0.0 was called "Impletio" which translates to infill.

This release is called "Prominentio" which means overhang.

Python API

rounded_cube()

The pythonscad module now includes a rounded_cube() helper (PR #738). It supports either radius (r) or diameter (d) style rounding, matching the style of existing OpenSCAD-like APIs.

from pythonscad import *

show(rounded_cube([40, 20, 8], r=2, center=True))

Single-file multi-tool 3MF export

MultiToolExporter can now export a single multi-part 3MF file (PR #831, PR #832). This is useful for multi-color and multi-material workflows where you want one file containing multiple named parts instead of a pile of separate files.

from pythonscad import *

exporter = MultiToolExporter()
exporter.append(("body", cube([40, 20, 8]).color("blue")))
exporter.append(("label", text("Py").linear_extrude(1).color("white")))

export(dict(exporter.parts()), "multi-tool.3mf")

Mesh color output

Meshes can now output color information (commit 01b2d6b), improving workflows that depend on colored geometry data during export or downstream processing.

from pythonscad import *

c=cube(10).color("pink")

# extract colored mesh information
vertices, triangles, colors, color_indices = c.mesh(color=True)

Virtual environment fixes

PythonSCAD now preserves the correct base executable when creating nested virtual environments from the bundled Python shim or from the GUI's Create Virtual Environment action (PR #873). This avoids ensurepip accidentally running through the PythonSCAD application option parser.

WebAssembly And Browser Support

PythonSCAD in the browser

This release adds a Python-enabled WebAssembly build based on Emscripten 6.0 and CPython 3.14 (PR #697, PR #777). That means PythonSCAD can run Python design code in a browser environment.

In-browser playground and notebook UI

There is now an in-browser playground with notebook-style UI and website integration (PR #800). This should make it much easier to try PythonSCAD without installing a desktop application first.

UI And Workflow Improvements

Bug report form

The GUI now includes a form-based bug report template and Help menu action (PR #751), making it easier to file useful reports with the right information attached.

Customizer behavior

Customizer text fields now defer preview updates until committed (PR #830), avoiding excessive preview refreshes while typing. Recent customizer values are also handled more reliably (PR #720).

External editor fixes

Launching gvim as an external editor is now more reliable (PR #806), and macOS tooltips now use Cmd instead of Ctrl where appropriate (commits 4936618, 5ab9d3b).

Platform And Packaging

Binary PyPI wheels

PythonSCAD is now much easier to install from PyPI (PR #744). Instead of building the full application stack locally during pip install, supported platforms can use pre-built binary wheels.

python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install pythonscad

This is a big step toward making PythonSCAD practical for automated model generation, CI pipelines, scripted exports, and small self-contained design projects.

Windows and macOS packaging improvements

The Windows and macOS packages now bundle IPython 9.x support with fixes for runtime dependency handling (PR #746, PR #792). Windows native packaging also gained fixes around the Python import library and CMake policy handling (PR #764).

Several late Windows packaging fixes make the packaged Python runtime more reliable: --repl and --ipython now find the bundled stdlib and native modules correctly, CPython sysconfig is initialized for packaged MSYS2 builds, and installer upgrades no longer report a false "Uninstall failed" result (PR #851, PR #860, PR #864, PR #866).

On macOS, bundled Python native extensions are now signed for notarization (PR #775).

AppImage and Linux package fixes

The release builds now cover AppImage, Debian/Ubuntu packages, RPM packages, PyPI wheels, WebAssembly, macOS, and Windows. Several CI and packaging fixes landed in this release, including OpenSSL development dependencies for Linux package builds (PR #846, PR #848).

AppImages now bundle the GMP runtime library and isolate more of their runtime environment from host libraries, including GIO modules and the Qt6 GTK platform theme path (PR #856, PR #857, PR #858).

Release smoke tests

v1.1.2 also adds automated release smoke tooling for AppImage, Linux package, macOS, and Windows artifacts (PR #870). The smoke checks cover application startup, .scad export, Python CLI export, REPL startup, and IPython startup, with follow-up fixes for local Windows artifact testing and Linux package artifact handling (PR #869, PR #872, PR #875).

Reliability And Bug Fixes

v1.1.2 includes many fixes across Python integration, geometry behavior, CI, and documentation:

  • resize() now accepts 1-3 element vectors from Python (PR #749).

  • nimport() works better on Windows and reports errors more clearly (PR #729).

  • Python script import paths are refreshed correctly on reinitialization (PR #843).

  • A segfault when cloning nodes for children() was fixed (PR #785).

  • Unsafe fillet topology is now reported more clearly (PR #809).

  • assert now emits a warning instead of hard-asserting (PR #810).

  • SVG/WebAssembly build issues were fixed, including compiling the SVG target with -fPIC for web builds (PR #798).

  • 3MF metadata is now XML-escaped correctly when exporting through the lib3mf v1 path, pulled in from the July 2026 OpenSCAD sync (PR #867).

  • Function representation nodes are now included in node cloning, avoiding another edge case in cloned CSG trees (PR #865).

  • The homepage and download UX were refreshed (PR #752).

Downloads

Pre-built packages are available for Linux, macOS, Windows, WebAssembly/browser use, and PyPI:

https://pythonscad.org/downloads/

As always, feedback, bug reports, and example projects are very welcome.


r/OpenPythonSCAD • • 2d ago Bravo

PythonSCAD v1.2.0 "Quadratum" released

8 Upvotes

Hi everyone,

We are happy to announce PythonSCAD v1.2.0 "Quadratum".

Four months and more than 750 commits after v1.1.2, this is our biggest release so far. The highlights:

  • patch() – a brand-new surface/solid construction primitive that builds geometry from a boundary plus holes (tube, panel and ring-bridge modes).

  • PyQt6 inside PythonSCAD – bundled PyQt6 bindings let your Python classes open their own interactive dialogs from the editor, and you can extend the GUI with your own forms.

  • Interactive dragging, reworked – drag rotate, scale and translate along their real paths, and drag the sizes of spheres, cylinders, cubes and polyhedra straight from the 3D view, with the code updated for you.

  • NumPy everywhere – NumPy arrays and tuples are accepted wherever lists are.

  • Better multi-object 3MF export, a new Export / Export as workflow, Customizer parameter containers and many more improvements.

Read on for the full list.

Release name

Following our tradition, release names are 3D-printing terms translated (loosely or directly) to Latin. v1.0.0 was "Impletio" (infill), v1.1 was "Prominentio" (overhang).

This release is called "Quadratum" which means "square".

Python API

New: patch()

patch() (formerly developed as a generalised loft()) builds surfaces and solids from an outer boundary and optional holes. Besides classic lofting it supports tangent-driven curvature and three modes – tube, panel and ring-bridge – and accepts 2D shapes as input (PR #1054, PR #950). patch(displacement=None) is accepted as well (PR #1146).

NumPy support across the API

NumPy arrays and tuples can now be passed wherever lists are accepted. New Vector1/Vector2/Vector3 and Matrix4x4 helper types are NumPy-backed when NumPy is installed and fall back to plain lists otherwise, so scripts work either way (PR #891, PR #916). See the NumPy support section in the math reference.

Customizer

Import and export

  • Multi-object 3MF from Python: top-level objects can be kept separate and are exported as individually named 3MF objects (using the Python variable name where available) (PR #1032).

  • osimport(..., split_by_color=True) splits a multi-color SVG into a dict of {color: 2D object} – perfect for multi-material prints (PR #887):

  • MultiToolExporter

    • hidden "cutter" entries take part in subtraction without being exported (PR #947)

    • prefix, suffix and mkdir move to export(); the constructor arguments are deprecated but still work (PR #1077)

    • parts are now rendered for F5 preview

  • STEP export writes proper units (PR #1128).

  • export() no longer writes files during F5 preview (PR #1010).

Other API improvements

  • rounded_cube() gained a center option (PR #912).

  • 2D .position / .size now return proper vectors, just like in 3D, so e.g. obj.translate(obj.position * -1) works for 2D objects (PR #1162).

  • osuse() falls back to the OpenSCAD library path after the local lookup (PR #967).

  • Calltips are now available for all functions (PR #926).

  • Type information (stubs) now ships with the wheels for better IDE support (PR #958).

  • An installable IDE shim package provides a placeholder openscad module with type information for editor completion when you are not running inside PythonSCAD itself.

Deprecations

PyQt6 integration and forms

PythonSCAD now ships PyQt6 bindings built against its own Qt6 (PR #904, PR #915). This opens up a whole new way of designing:

  • A Python class can define an interactive dialog (e.g. a point-editing canvas for a polygon) which opens when you click its calltip in the editor – the edited values are written back into your code.

  • The new pyscadforms library provides ready-made building blocks.

  • Together with .pythonscadrc and add_menuitem() you can extend the PythonSCAD GUI with your own tools. .pythonscadrc is now loaded from the PythonSCAD config directory.

On Linux, packages use the distribution's PyQt6, AppImages bundle it. See the new developer documentation on pythonscad.org.

GUI

  • Interactive dragging reworked (PR #1168):

    • drag rotate, scale and translate along their real path

    • drag sphere, cylinder, polyhedron and scalar cube sizes

    • support for marked() values; variables are changed at their definition

    • smoother point dragging with a clearly visible (azure) drag handle

  • Export… / Export as… (GIMP-style): remembers path, format and options per tab, replacing the per-format export submenu (PR #1042).

  • Render-first prompts for Export (F7) and 3D Print (F8): if the design has not been F6-rendered since the last change (or never rendered), a dialog now offers Render and Export / Render and Print instead of failing. See Slicer integration for configuring a local slicer with F8 (PR #1042).

  • Fullscreen mode (F11) and unified window-geometry persistence (PR #995).

  • Creating a Python virtual environment from the GUI is much more robust (runs in a subprocess, bootstraps pip when needed, Windows fixes) (PR #1219).

  • Nord color schemes and more consistent theme / face-color handling in preview and render (upstream #7033, PR #1217).

  • Search state is preserved across tabs, rendering is cancelled before closing a tab, and the icon theme survives OS theme changes.

  • .scad files are registered as default and .py files as "Open With" on all platforms (PR #1154).

Geometry fixes

  • Fillets with r= now also work on 2D union/difference (PR #1069).

  • Fixed fillet self-intersections at 3-way corners (issue #994, PR #1049).

  • wrap() no longer drops slices of wrapped solids (PR #1043).

  • pull() no longer drops faces on axis-aligned cuts and keeps pulled cavities in the final render (PR #1131, PR #1201).

  • Correct circular segment count in fillets (issue #985).

  • Degenerate triangles no longer cause asserts on export and are skipped in 3MF (PR #1114, PR #1163).

  • Deterministic results: no more rand() in geometry code (PR #1053).

  • SVG fill:none is treated as unpainted instead of invisible geometry (PR #987).

  • Fixes for multmatrix, invalid color names and a crash in color().

Web playground (WebAssembly)

  • Complete models render without a CGAL fallback (PR #935).

  • The playground stays responsive during evaluation, the debug log is hidden by default, and navigation is clearer.

  • A reusable WASM toolchain image is published on GHCR.

Translations

All translations were completed, and Latin and Esperanto were added (PR #951, PR #1078).

Merged from upstream OpenSCAD

We kept merging upstream OpenSCAD regularly. Notable changes include:

  • Unicode (non-ASCII) identifiers following UAX #31

  • import() derives the file type from the extension and allows specifying it explicitly

  • sphere(style = "octa") octahedral tessellation (default remains "orig")

  • fragments(r|d) returns how many sides a circle of that size would get under the current fn / fa / fs settings (also available from Python)

  • object() and JSON import() are no longer experimental

  • AMF import/export removed; OFF import improvements and header fix

  • AI assistant: tool calling, chat export/import, viewport tools and agent modes

  • Nord color schemes

  • Keyboard shortcuts for all menu items, move line up/down shortcut

  • Custom CA certificates via PEM file, IPv6 URL fix

  • SVG: entity handling fix and limited <use> expansion

  • Warnings when parameter limits are adjusted, NFC-normalised parameter set names

  • Open files with non-ASCII paths on Windows

  • Updated German, French, Swedish and Galician translations

Packaging and platforms

  • macOS: releases are built for macOS 15 on Apple Silicon (Intel runners were retired); fixed an Apple Silicon startup crash.

  • Linux: AppImage is now built on Ubuntu 24.04 and is Qt6-only (the Qt5 AppImage is gone); Debian 11 (bullseye) is no longer supported; supported distribution targets were refreshed (including newer Ubuntu and Enterprise Linux releases) (PR #1252).

  • Windows: improved Python import library generation and venv handling.

  • PyPI wheels ship a real lib3mf on manylinux and include type information.

  • Updated Nix build (thanks to @mvirts) and macOS dependency build fixes (thanks to @javax0).

  • New release smoke tests run against the packaged artifacts on clean runners.

Thank you

A big thank you to everyone who contributed to this release – especially (in alphabetical order) dasbidyendu, gsohler, javax0, John Neo, mvirts, nomike, pinkfish and Shadowjump – and to everyone who reported bugs and tested pre-releases.

Download PythonSCAD v1.2.0 from pythonscad.org. If you've installed PythonSCAD in a Python virtual environment, simply run pip install --upgrade pythonscad.

Happy designing!


r/OpenPythonSCAD • • Apr 15 '26

PythonSCAD v0.20.0 released

8 Upvotes

Hi everyone,

We’re happy to announce PythonSCAD v0.20.0. The headline change is session management: the app can remember how you left off and bring that workspace back on the next launch. This is similar to what applications like NotedPad++ and Visual Studio Code are doing. We’ve also improved reliability in a few places, rounded out Python API documentation, and made small quality-of-life updates. Full technical notes are in the changelog on the release PR.

Session management (new)

v0.20.0 introduces session persistence. When you quit and reopen PythonSCAD, you can get back your open tabs and editors, multi-window layout, customizer state, view and find state, and per-tab language—so routine work is easier to resume without rebuilding your environment from scratch.

The feature also includes autosave-style crash recovery, a clearer flow when closing tabs with unsaved changes, and a session option in Advanced preferences if you want to control the behavior. Customizer tweaks can apply without always pressing F5, and the stack includes dry-run safety so heavy preview work is harder to trigger by accident.

All of this ships as one coherent capability (see PR #415).

Note: To go back to the old behavior, you can go to Edit > Preferences > Advanced and disable the session management option. We tested this new feature quite extensively, but any feedback or bug reports on this new feature will be highly appreciated.

Improved unsaved-files dialog

When you want to close PythonSCAD a new dialog will list unsaved tabs and allow you to individually save them or decide to not save the remaining unsaved changes.

Save dialogs and editor language

Save and Save As now match the editor language you’re in: suggested names and filters line up with .py vs .scad, including sensible default folders so native file dialogs behave reliably. This addresses incorrect defaults some people hit in Python mode (#534).

Thanks @bereldhuin for reporting this.

Reliability and polish

  • Context menu / right-click handling is more robust, with fewer crashes in edge cases.

  • The measure tool again shows correct vertex indices when you need them.

  • Windows builds use the PythonSCAD logo in the application and nightly resources (#543, #544).

Documentation

Upstream changes

Of course we merged all changes from OpenSCAD into our codebase again to get the latest bugfixes and enhancement from our upstream project.

Downloads

Pre-built packages are available for Linux (AppImage, .deb, .rpm), macOS (DMG), and Windows (installer and zip):

https://pythonscad.org/downloads/

As always, we’d love to hear from you—feedback and bug reports are welcome!


r/OpenPythonSCAD • • Aug 11 '25

Cool Mech kinematics script in PythonSCAD

8 Upvotes

I've spent several weekends rebuilding one of my prior OpenSCAD projects in PythonSCAD. After a very late night I've gotten it fully rigged with inverse kinematics, something that was straight up impossible in SCAD and was what forced the switch. I need to clean it up into a usable toolbox, but its promising to be significantly simpler to continue expanding on than the SCAD equivalent had.


r/OpenPythonSCAD • • Oct 20 '24

Visitors read this first

8 Upvotes

Hi OpenPythonSCADers,

In order to prevent, that this Subreddit gets marked as SPAM channel again,

r/openpythonscad was set up as closed/private reddit.

However, if you like the topic and feel like you want to contribute here , do not hesitate to write a small message to the Mods. "Message the Mods"

We are happy to add you to the group!


r/OpenPythonSCAD • • Sep 29 '26

PythonSCAD 1.2: `patch()` — a completely new way to build solids from freeform surfaces (with holes!)

7 Upvotes

Hey everyone, loft just got merged into PythonSCAD, and with it comes a new primitive I'm pretty excited about: patch(). ![patch() result — tube wall with tap holes cut directly into the surface]

The problem it solves

In classic OpenSCAD/CSG modeling, if you want a curved wall with holes in it — say, a tube with a couple of mounting taps drilled through — you build the tube, build the holes as separate solids, and subtract them. That works, but it gets slow, fragile, and numerically messy as soon as the geometry gets organic: curved shells, freeform surfaces, holes that sit close to edges or to each other. patch() skips the boolean-subtraction step entirely. You describe the surface directly — an outer boundary curve, plus any number of holes cut into it — and patch() triangulates the whole thing as one clean, watertight mesh from the start. No CSG needed for the holes.

What it looks like in practice

wall1 = patch(r1, holes=[r0, tap1, tap2], grid_spacing_uv=3)

Check result at https://imgur.com/a/fbY1Jon

Here r1 is the outer boundary of a tube wall, and r0, tap1, tap2 are hole outlines (in this case two small circular tap holes) cut directly into that wall. grid_spacing_uv controls the mesh resolution. One call, one clean surface — taps included. Define 2,5d "interfaces" in space and create partches between these. use concat to create a watertight surrface from multiple patches to create a solid which can optionally further processed by CSG operations

Under the hood

patch() builds its own local UV parametrization of the surface (with proper handling of periodic/wrap-around cases like tube walls), runs a custom incremental Delaunay triangulation, and does robust inside/outside testing against the hole boundaries — including the tricky edge cases where a hole's boundary is exactly tangent to a triangulation ray (a classic point-in-polygon pitfall that's easy to get subtly wrong). The result is a mesh that stays clean even for holes sitting right at a surface's curvature extremes.

Why this matters

  • Freeform / organic surfaces with cutouts, without fighting CSG robustness issues

  • Faster and more predictable than difference() on curved geometry

  • Opens the door to proper "patch modeling" workflows (think: surface-based CAD, not just solid CSG) directly in Python This is part of the bigger loft feature landing in PythonSCAD 1.2. Give it a spin and let me know what you build with it! GitHub: https://github.com/pythonscad/pythonscad


r/OpenPythonSCAD • • Mar 10 '26

PythonSCAD v0.18.0 Released

7 Upvotes

Hi everyone,

We're happy to announce PythonSCAD v0.18.0. Unfortunately, v0.17.0 had a serious bug: the app wouldn't start on many Windows and macOS systems. We've fixed that in this release. Because we were already working on the next update, v0.18.0 also includes several other improvements — so it's both the fix and a solid update.

Windows and macOS: App Starts Correctly Again

If you tried v0.17.0 on Windows or macOS and the app failed to launch (or showed an error like 0xc0000142), the problem was with how the installers were built: they only worked on a narrow set of CPUs. We've fixed the build process so the Windows and macOS packages now run on a much wider range of computers. If v0.17.0 didn't work for you, please use v0.18.0.

Better Light and Dark Themes

Light and dark mode now behave correctly on all platforms. On Windows, menu text in Light Mode is no longer invisible. On Linux, the theme you choose (including "Auto – follow system") is respected properly, even after restart. You should see consistent, readable themes everywhere.

Dialog and Interface Fixes

Save dialogs, and other pop-ups no longer flicker on some setups (especially when using Qt5). We've also cleaned up compatibility with newer Qt versions so the app stays stable and warning-free.

PyPI Coming Soon

We've laid the groundwork to publish PythonSCAD on PyPI. Soon you'll be able to install it with pip install pythonscad or use it as a dependency in your Python projects — we'll announce when that's live.

Documentation

The rendervars() function (for controlling the 3D view from Python) is now documented in the cheat sheet and tutorial, with examples.

Downloads

Pre-built packages are available for Linux (AppImage, .deb, .rpm), macOS (DMG), and Windows (installer and zip):

https://pythonscad.org/downloads/

As always, we'd love to hear from you — feedback and bug reports are welcome!


r/OpenPythonSCAD • • Mar 08 '26

PythonSCAD v0.17.0 Released

7 Upvotes

Hi everyone,

There have been many releases in the past few months with smaller or bigger updates and fixes. We're now experimenting with posting release announcements from now on with every new release. This should help you follow along with the progress of the project.

Please let us know what you think!

So without further ado we're happy to announce the release of PythonSCAD v0.17.0! Here's what's new:

OpenSCAD Render Variables Now Available in Python

All OpenSCAD render variables are now accessible in PythonSCAD as well. This includes $t (animation time), $preview, $vpt (viewport translation), $vpr (viewport rotation), $vpd (viewport distance), and $vpf (viewport FOV). This brings PythonSCAD to full parity with OpenSCAD for animation and viewport-aware scripts.

Set Viewing Perspective from Python

You can now programmatically control the 3D viewport from Python code. The new setrender() function allows you to set the camera's viewing perspective directly from your scripts, making it easier to create reproducible views of your models. This is literally the opposite of above function. just type e.g. setrender(vpd=100)

New Window Opens with Python Tab

Previously, using File > New Window would open a new window with an "Untitled.scad" tab. Since PythonSCAD defaults to Python, this now correctly opens with an "Untitled.py" tab instead. (Fixes #472)

Code Quality: Static Analysis Cleanup

A thorough static analysis pass was run on src/python/ using cppcheck, resulting in several fixes:

  • Fixed a memory leak and two null pointer dereference bugs in the Python/C data layer

  • Removed ~30 unused variables (including a leaked PyUnicode_FromString allocation)

  • Replaced undefined-behavior type-punning with portable std::memcpy in FrepNode

  • Improved const correctness and fixed confusing shadow variable names

GCode Export Refactoring

The GCode export internals were refactored to pass options via a clean ExportGcodeOptions struct instead of individual parameters. Error handling was also improved -- unsupported geometry types now print descriptive error messages instead of crashing via assert(false).

Upstream Sync

PythonSCAD was synced with upstream OpenSCAD as of 2026-03-04, bringing in fixes for dock state initialization, manifold bumps, subtraction color for nefs, and Python GC improvements.

Up next

The next release is already taking shape. It will add proper documentation for the new setrender() function, which didn't make it in this one yet. There will be some fixes in regards to the light/dark themes and we're working on making PythonSCAD available on PyPi as well (which will allow you to use pythonscad as a dependency in your projects or just install it in a virtual env using pip). So stay tuned for more updates.

Downloads

Pre-built packages are available for Linux (AppImage, .deb for Debian/Ubuntu, .rpm for Fedora/RHEL), macOS (DMG), and Windows (installer and zip):

https://pythonscad.org/downloads/

As always, feedback and bug reports are welcome!


r/OpenPythonSCAD • • Dec 28 '25

Initial support of Full Control G-code in gcodepreview by way of OpenPythonSCAD

Thumbnail
github.com
7 Upvotes

r/OpenPythonSCAD • • Sep 18 '25

PythonSCAD got a new primitive

7 Upvotes

Its called 'sheet' and it can be used to create a surface which established by sweeping 2 indepent variables.

Simples case might be this one:

But this can be arbritary extended

This could be a solid car tire. its closed by i and j variable.

This is basically a rotate_extruded lisajous shape.

Look forward to testing more fancy shapes


r/OpenPythonSCAD • • Jun 01 '25

How do I do vector math cleanly?

7 Upvotes

My OpenSCAD code tends to have a lot of vector math in it. While I was setting up my first PythonSCAD project I came to the realization that Python can't do vector math the same way as OpenSCAD, at least not intuitively. Looking around, it looks like numpy is my best bet for doing vector math, but every vector needs to have tolist() on the end of it or it can't be interpreted.

Here's a simplified example of what my OpenSCAD code might look like:

vec_n=vec/norm(vec);

scalar=12;

translate(scalar*vec_n)
cube(5,center=true);

And here's how I got it to work in PythonScad:

from openscad import *
import numpy as np

vec=np.array([5,4,3]);
vec_n=vec/np.linalg.norm(vec);

scalar=12;

c=cube(5,center=True)
c=c.translate((scalar*vec_n).tolist())
c.show();

Is there anyway to make it work without all these references to numpy? Or at the very least, without having to call tolist() every time I translate something?


r/OpenPythonSCAD • • Jan 02 '25

Using CadQuery features in your design

7 Upvotes

OpenSCAD is very versatile. PythonSCAD has some added features and another language, for those,

who prefer. Lately its even possible to leverage from powerful librraries like BOSL2.

But there might still be cases where you want to use CadQueries abilities instead. Build123d is a beautiful python layer on top of OCCT. Build123d and CadQuery share same the same OCCT kernel

You can easily mix it into your PythonSCAD code.

just "decorate" your build123d functions in your design accordingly.

Use this simple code .with any version from 20250102 ....

from openscad import *
from pybuild123d import *
from build123d import *

@build123d  
def build123d_demo():
    with BuildPart() as demo:
        Cylinder(radius=10, height=3)
        with BuildSketch(demo.faces().sort_by(Axis.Z)[-1]):
            RegularPolygon(radius=7, side_count=6)
            Circle(radius=4, mode=Mode.SUBTRACT)
        extrude(amount=2, mode=Mode.ADD)
        fillet(
            demo.edges()
            .filter_by(GeomType.CIRCLE)
            .sort_by(SortBy.RADIUS)[-2:]
            .sort_by(Axis.Z)[-1],
            radius=1,
        )
    return demo        
obj = build123d_demo()
obj |= cylinder(d=3,h=20,fn=20)
obj.show()

r/OpenPythonSCAD • • Dec 15 '24

Using existing SCAD libraries in PythonSCAD

7 Upvotes

This small demonstration shows, how you existing libraries along with your PythonSCAD code.

Simple use "osinclude" to turn a SCAD library into an class variable with all the modules and variables available as members.

You can simple call these members by invoking them with parameters. Even Childs to SCAD modules are possible. just add them to the arguments

This feature is available since 2024-12-15 Windows release.


r/OpenPythonSCAD • • Apr 16 '26

Textures in PythonSCAD

6 Upvotes

Inspired by websites like meshtexture.com or bumpmesh.com my focus last days and weeks were texture again. They are a great addition to solid modelling; not only pretty looking but they could also add some structure to handles so you can better grab them.

But having "texturing" on board is both an adavtantage in less tools, faster model, and the ability to use serveral texures in your model.

In Order to successfully "texture" a solid you need to provide a way to "accept" all details of the texture, this is basically remeshing with a finer grid or literally "oversampling".

Texturing itself is just the small dot on the "i" , but it comes with lots of projection flavors.

Projection determines, how a X and Y coordinate of the Texture maps to the the solid. Some of them are cubic, spherical, cylindric, triplanar, planarx, planary, planarz.

Long story short: here is an example how you can upcycle the surface of *any* derived solid

like so:

And yes - you can mix any texture and any color in your design.

The "oversample" function accepts parameters like "size" "texture" "texturewidth" "textureheight" "texturedepth" .

Texture is the name/path of a png file similar to osimport or surface. width an height are the sizes of a single texture canvas on your model whereas depth controls the carving depth of black color in your model.

The code for this model is available at https://bpa.st/EQPRG

This feature was merged today into the source code and will be available on next release.

Feel free to share your favorite models on thingiverse. Happy texturing,


r/OpenPythonSCAD • • Feb 24 '26

PythonSCAD goes Jupyter

6 Upvotes

Jupyter is a web interface which is mainly uses in science.

Its somewhat similar to a Calculator.

Why shouln't that be used to create 3D models ...

https://youtu.be/pXBKZfUDQ9c

Instructions how to use will follow soon


r/OpenPythonSCAD • • Jul 24 '25

Landscape modelling with PythonSCAD

6 Upvotes

With the new colored surface, textures become super easy.

Together with faces() and other auxiliary functions, landscape modelling becomes fairly user friendly.

The Source code can be found here: https://bpa.st/RT4Q


r/OpenPythonSCAD • • Mar 17 '25

A work in progress: honeycomb mesh as a library on top of pythonscad

Post image
6 Upvotes

r/OpenPythonSCAD • • Sep 02 '26

PythonSCAD is getting user-defined Customizer widgets (PyQt6-powered) — coming in 1.2

5 Upvotes

Hey folks, Wanted to share something we've been building for PythonSCAD: the Customizer sidebar can now host fully custom, Python-defined input widgets — not just the built-in sliders, checkboxes, and dropdowns.

What does that actually mean?

Normally, add_parameter() gives you a fixed set of widget types based on the default value you pass in — a number gets a slider, a string gets a text box, a list gets a vector editor, and so on. That covers a lot of cases, but not everything. Sometimes you want something the built-in types just can't express well. With this change, you can register your own widget, built with PyQt6 (which now ships bundled with PythonSCAD), and hook it directly into the Customizer:

add_parameter_widget("color_picker", color_picker_factory)
linecolor = add_parameter("linecolor", "#ff00ff", type="color_picker")
cube(10).color(linecolor)

color_picker_factory is just a normal Python function that returns a PyQt6 widget — in this case a button that pops a native color dialog and reports its value back. From the Customizer's point of view, it behaves exactly like any other parameter: it saves to sets, restores on load, and drives a live preview re-render the moment you change it. One thing worth calling out: add_parameter_widget() itself belongs in your .pythonscadrc, not in the model script. It's registering a widget type, not something tied to a particular design, so it lives with your personal setup and is available to every script you open, the same way you'd register a menu item or an editor helper. (Side note: PyQt6-based custom input windows aren't actually new here — user modules could already pop their own PyQt6 dialogs, e.g. for interactively editing a polygon's points. What's new is hooking a custom widget directly into the Customizer sidebar itself.) Because the widget is just PyQt6, this isn't limited to color pickers — anyone can build their own: a polygon point-editor with drag handles, a curve editor, a searchable dropdown, a live 3D preview widget, whatever your script needs. If PyQt6 can render it, the Customizer can host it.

Demo

Here's a short video showing it in action (color picker widget, live-driven from the Customizer): 🎥 https://www.youtube.com/watch?v=OESyfZGZj_I

Where this is headed

This is landing as part of PythonSCAD 1.2, which is on its way — the PyQt6 connector work that makes this possible has already been merged. More documentation and examples will follow closer to release.


r/OpenPythonSCAD • • Feb 27 '26

Creating jjigsaw puzzles for easter

5 Upvotes

Ain't Lasercutter perfect for puzzles ? they can do the PIcture and the cuting.

Thanks to the spline and random function, PythonSCAD can create unique puzzle on each

run. Code can be found here:

https://bpa.st/DRUQ

I just used a nice SVG file which can easily be found in the internet

Production in the printer is actually way easier. its illustrated here:

Let's get ready for easter


r/OpenPythonSCAD • • Jan 25 '26

Creating LaserCuts with PythonSCAD

5 Upvotes

Something which PythonSCAD did not yet touch is lasercuts.

Plywood mostly acts as an objects surface for DIY lasercut art, so PythonSCAD's faces()

function is a great location to start with, so I started codeing an utiliy library 'pylaser' for that. Also there were quite some improvements inside PythonSCAD for better 2D support.

E.g. now its even possible to alter polygons after they were created

Imagin you have this code:

'''

from openscad import *

from pylaser import *

b=cube([30,30,20])

f=b.faces()

lc = LaserCutter(b.faces())

#lc.preview()

lc.finalize()

...

Results are:

But this is just the tip of the ice-berg. My plan is beeing able to be way more liberal and not having to stick to the faces() function, but also create my own compositions. Many Ideas yet to implement

Ideas welcome!


r/OpenPythonSCAD • • Jan 07 '26

Dropping QT5 support for Windows

5 Upvotes

Today MSYS2 introduced an update to qt5-base which broke the qt5 build for PythonSCAD.
I asked on their Discord for advice but didn't receive any response.

As QT5 is end of life since 26th of May 2025, I just decided to no longer test it on Windows or build releasables for it. As QT is bundled with PythonSCAD on Windows, I don't think there will be much impact by this change.

We already had QT5 phased out from macOS when I joined the project last year as QScintilla (the source code editor component PythonSCAD uses) is not packaged for QT5 on macOS Homebrew.

So as of now QT5 versions are only built for Linux (especially since there are no QT6 builds for Ubuntu 22.04 LTS which still supported by Canonical until April 2027).

I heard that OpenSCAD is considering phasing out QT5 altogether, at which point we will most likely follow suit.

Let us know if the removal of a QT5 version for Windows is an issue for you.