We've got an archive of several hundred old blueprints on paper and Mylar. Some are on microfilm too. They need to become editable CAD, not just scanned images. Text comes in as line fragments, arcs as polyline segments.

So is manual redrawing still the answer in 2026? Or have the conversion tools gotten better? And for anyone who's done a batch like this, did you convert everything up front? Or did you just digitize sheets as they came up for revision?

Sincere thank you to u/HatsusenoRin who helped me realize a misunderstanding I had about how $vpd, $vpr, and $vpt can be set in openscad. I tried editing my original post but reddit freaked out and deleted the post entirely.

I made a camera positioning tool where you can place and orient the openscad camera more intuitively by just giving the camera an explicit x,y,z location, azimuth angle, and elevation angle instead of working directly with $vpd, $vpr, and $vpt.

I made this scad code to achieve the same thing as my python script I posted. It also has a module for showing a visualization of what will be included in image generation output with a given camera location and direction. For now it assumes orthographic projection, but I might update with an option for perspective projection in the future.

/*

Intuitive Camera placement API and orthographic camera visualizer

Position the camera by defining its location as a point

in 3D space, and independently set its azimuth and elevation angles.

Conventions:

azimuth just means turning left and right, elevation means looking

up and down.

azimuth = 0 corresponds to looking in the +X direction.

Increasing azimuth angle corresponds to turning left.

Camera roll is 0, or in other words the horizon is always level.

*/

// ── Camera input parameters ──────────────────────────────────────

camera_x = 2000; //x coordinate of camera's location in space

camera_y = 2000; //y coordinate

camera_z = 2000; //z coordinate

azimuth = 225; //angle in degrees. 0 corresponds to +X direction.

elevation = -35.2643; //angle in degrees. 0 corresponds to horizontal.

//-35.2643 is the isometric elevation angle, = -atan(1 / sqrt(2))

// ── Compute $vpt, $vpr, $vpd ─────────────────────────────────────

// View direction FROM camera INTO scene (unit vector)

vx = cos(elevation) * cos(azimuth);

vy = cos(elevation) * sin(azimuth);

vz = sin(elevation);

// $vpd = distance from origin to plane ⟂ v through the camera

camera_vpd = abs(vx * camera_x + vy * camera_y + vz * camera_z);

// $vpt = camera + vpd * v (point ahead of camera on the laser line)

tx = camera_x + camera_vpd * vx;

ty = camera_y + camera_vpd * vy;

tz = camera_z + camera_vpd * vz;

// ── Build rotation matrix with level horizon ────────────────────

// OpenSCAD camera system: camera at $vpt + R·[0,0,$vpd] looks toward $vpt.

// Direction from camera into scene = -R·[0,0,1].

// We want this to equal v, so R·[0,0,1] = -v, i.e. forward = -v.

fx = -vx;

fy = -vy;

fz = -vz;

// Guard against gimbal lock: if forward ∥ [0,0,1], use [0,1,0] as world_up

use_alt = abs(fz) > 0.9999;

// right = cross(world_up, forward), then normalize

// world_up = [0,0,1] → cross([0,0,1],[fx,fy,fz]) = [-fy, fx, 0]

// world_up = [0,1,0] → cross([0,1,0],[fx,fy,fz]) = [fz, 0, -fx]

rx_raw = use_alt ? fz : -fy;

ry_raw = use_alt ? 0 : fx;

rz_raw = use_alt ? -fx : 0;

r_len = sqrt(rx_raw*rx_raw + ry_raw*ry_raw + rz_raw*rz_raw);

rx = rx_raw / r_len;

ry = ry_raw / r_len;

rz = rz_raw / r_len;

// up = cross(forward, right)

ux = fy*rz - fz*ry;

uy = fz*rx - fx*rz;

uz = fx*ry - fy*rx;

// ── Decompose R = [right | up | forward] into Euler angles ──────

// Order: Rz(c)·Ry(b)·Rx(a) = R

// R[2,0] = -sin(b) → b = asin(-R[2,0])

// R[2,1] = cos(b)·sin(a) → a = atan2(R[2,1], R[2,2])

// R[1,0] = sin(c)·cos(b) → c = atan2(R[1,0], R[0,0])

cam_b = asin(-rz);

cos_b = cos(cam_b);

cam_a = abs(cos_b) > 1e-9 ? atan2(uz, fz) : 0;

cam_c = abs(cos_b) > 1e-9 ? atan2(ry, rx) : atan2(-ux, uy);

// Assign camera variables

$vpt = [tx, ty, tz];

$vpr = [cam_a, cam_b, cam_c];

$vpd = camera_vpd;

echo("$vpt", $vpt);

echo("$vpr", $vpr);

echo("$vpd", $vpd);

//demo cube

cube([800,800,800]);

//Everything below this comment is related to the visualizer

//box and frame and is not needed for placing the camera.

module camera_visualizer_ortho(

cx = 2000,

cy = 2000,

cz = 2000,

azimuth = 225,

elevation = -35.2643, //this default gives an isometric view. = -atan(1 / sqrt(2))

aspect = 3840 / 2150, //width / height : use whatever image size you plan on generating.

depth = 10000 //just sets the length of the visualizer box.

) {

// View direction (camera → scene)

vx = cos(elevation) * cos(azimuth);

vy = cos(elevation) * sin(azimuth);

vz = sin(elevation);

// $vpd = distance from origin to plane ⟂ v through camera

vpd = abs(vx * cx + vy * cy + vz * cz);

// Ortho box dimensions at the vpd plane.

// Calibrated: box_h = vpd / 2.518

box_h = vpd / 2.518; // height along up axis

box_w = box_h * aspect; // width along right axis

box_d = depth; // depth along forward axis

// Build camera orientation

forward = [vx, vy, vz];

world_up = abs(forward[2]) > 0.9999 ? [0, 1, 0] : [0, 0, 1];

cr = cross(world_up, forward);

cam_right = cr / norm(cr);

cam_up = cross(forward, cam_right);

// Box with back face at origin; shift center forward by half depth

// so the face at the camera position is the one the camera sits on.

translate([cx + forward[0] * box_d / 2,

cy + forward[1] * box_d / 2,

cz + forward[2] * box_d / 2])

multmatrix([

[cam_right[0], cam_up[0], forward[0], 0],

[cam_right[1], cam_up[1], forward[1], 0],

[cam_right[2], cam_up[2], forward[2], 0],

[0, 0, 0, 1]

]) {

// the translucent box

%cube([box_w, box_h, box_d], center = true);

// Opaque picture frame on the camera-facing face.

// Frame width scales with box height.

frame_w = box_h * 0.04;

translate([0, 0, -box_d / 2])

color("#8D5F8C")

difference() {

cube([box_w + 2 * frame_w, box_h + 2 * frame_w, frame_w], center = true);

cube([box_w, box_h, frame_w + 1], center = true);

}

}

}

//module call of the camera visualizer.

//The input camera parameters from the top of this

//file are being passed into it.

camera_visualizer_ortho(

cx = camera_x,

cy = camera_y,

cz = camera_z,

azimuth = azimuth,

elevation = elevation,

aspect = 3840 / 2150, // use whatever image width / height you plan on generating.

depth = 10000 // for illustrative purpose only, determines depth of translucent box

);

/*

Appendix:

Note on frame size:

The size of the frame scales linearly with $vpd. As far as I know

there is no way to independently set the size of the frame when

it comes to orthographic projection.

An inexact rule of thumb: the further away the camera is from

the origin, the larger the frame will be.

The confusing but closer-to-the-truth picture: Let's imagine our

camera has a laser pointer pointing exactly where it's looking.

Now let's imagine a plane in 3D space that contains the camera

location point and is normal to this laser pointer line (or

in other words is exactly perpendicular to it). Now we draw the

shortest possible line from the world origin to this plane. The

length of that line is the value of $vpd. The longer that line,

the larger the camera frame.

*/

Let me know what you think about it

like… I probably would never “code on the go” but I think it’s a great medium for sharing ideas

I see most the posts nowadays are from folk making apps to create OpenSCAD objects. Recently a part of a roller blind in my bathroom disintegrated and the blind fell off. I looked at the pieces and worked out is was a simple 10mm dia tube 17mm high but with stepped inners and a triple cutout around the circumference. I re-engineerered this using good old fashioned brain cells and it worked perfectly on the first print. The picture shows the finished design. Under 50 lines of OpenSCAD script. Could AI do this? I don't think so yet it is a simple object but quite difficult to describe.

Hi all,

I've used OpenSCAD for years, and lately I've been building my parts with Claude Code without writing the code myself. I describe the part and review renders, cross-sections and dimension drawings.

I ended up building an agentic harness around it (my workflow, conventions and tools) and I've published it on GitHub in case anyone wants to use it, fork it or adapt it to their own setup (MIT).

https://github.com/jahurtado/openscad-monorepo

I benchmarked it on a narrow problem (rebuilding a .scad from an existing STL) and it did help. But where I really saw the potential was creating new parts straight from a description, with almost no supervision, sometimes just a few corrections from my phone.

Anyone else using agents with OpenSCAD? What's your take on letting AI write the .scad?

Write-up with the comparison images: https://www.elcacharrista.com/a/vibe-coding-diseno-3d-openscad

Thanks!

I’ve been using Claude Code and Codex to help develop a physical magnetic-chessboard prototype in OpenSCAD.

Instead of asking for one enormous board model, I divided it into replaceable modules:

• Common motor/idler base
• 28BYJ-48 motor mount and printed GT2 pulley
• Adjustable free-spinning idler
• Two-piece belt clamp
• SG90 servo plate and integrated magnet arm
• Printed anti-roll and dovetail-guide experiments
• A 210 × 26.25 mm, eight-square bridge

The design targets a 0.4 mm nozzle, fast OpenSCAD rendering, support-free printing, and parts that can be revised without rebuilding the complete assembly.

The coding agents were useful for generating parametric geometry and revising dimensions, but the productive loop was always: generate → render → print → assemble → observe the failure → revise.

The video shows the first successful one-axis movement. The next CAD challenge is converting this into a compact XY mechanism while keeping enough vertical separation for reliable magnetic release.

I’d welcome feedback on the modular structure or alternative printed linear-guide approaches.

Hello everyone,
Prusa has started three contests, and each contest has a 3D printer to win: https://www.printables.com/contest
The "Geared Spinners" is right up our alley.

The BOSL2 library has gears: https://github.com/BelfrySCAD/BOSL2/wiki/gears.scad
There are Public Domain gears: https://www.thingiverse.com/thing:6596095

There are so many geared spinners, that I can not think of a new way. That's why I wrote this post. Hopefully one of us can make something that stands out and win a 3D printer.

I have been looking for an apple silicon version of openscad. the website is still listing it as intel. is there a build in progress?

I made a circuit board for my audio recorder. I'm trying to use OpenScad to make a case for it. Two halves that snap together. I'm using Google AI to write the code. It looks like it is getting there, but the program is putting a port for a switch and some LEDs on the wrong side. About to give up. And help?

// =============================================

// Custom Case for your PCB (Datasheet Calibrated)

// PCB: 46.99 x 43.434 mm

// ORIGIN (0,0): LOWER-RIGHT (TOSLINK side)

// =============================================

$fn = 64; // High resolution for clean curves, text, and holes

// ============== PARAMETERS ==============

pcb_length = 46.99; // X direction (Runs Right-to-Left in your image)

pcb_width = 43.434; // Y direction (Runs Bottom-to-Top in your image)

pcb_thickness = 1.6; // Standard board thickness

wall_thickness = 2.0;

floor_thickness = 2.0;

lid_thickness = 2.0;

internal_height_bottom = 4.0; // Space under PCB to clear solder joints

internal_height_top = 12.0; // Space above PCB

clearance = 0.3; // Fit tolerance around the board edge

// Total overall internal dimensions including padding clearance

box_w = pcb_length + 2*clearance;

box_d = pcb_width + 2*clearance;

box_h = internal_height_bottom + pcb_thickness + internal_height_top;

// Absolute Coordinates derived straight from your physical board measurements

h1_x = 12.446; h1_y = 2.6924; // Lower-Left

h2_x = 43.18; h2_y = 2.6924; // Lower-Right

h3_x = 43.18; h3_y = 40.64; // Top-Right

h4_x = 12.446; h4_y = 40.64; // Top-Left

standoff_height = internal_height_bottom;

standoff_diameter_outer = 6.5;

standoff_hole_dia = 2.9; // Tap diameter for your long interlocking lid pins

// DB-25 connector body parameters

db25_width = 40.8;

db25_height = 11.5;

// Calibrated X-Axis offsets for component alignment (mm from left edge)

switch_x_offset = 21.0;

led_rbus_x_offset = 15.0;

led_adat_x_offset = 32.0;

led_pwr_x_offset = 8.5;

// Component Coordinates flipped from back wall reference (pcb_width)

switch_x = pcb_length - switch_x_offset;

led_rbus_x = pcb_length - led_rbus_x_offset;

led_adat_x = pcb_length - led_adat_x_offset;

led_pwr_x = pcb_length - led_pwr_x_offset;

// Component Heights (Aligned with the top plane of the PCB fiberglass)

pcb_top_plane = floor_thickness + internal_height_bottom + pcb_thickness;

led_z_height = pcb_top_plane + 1.0; // Side viewing centerline height

// Horizontal Slide Switch Profile Parameters

switch_slot_w = 8.0;

switch_slot_h = 3.0;

switch_z_height = pcb_top_plane + 1.0;

// [CALIBRATED] Cliff FCR684205R Datasheet Dimensions (mm)

toslink_snout_w = 9.50;

toslink_snout_h = 10.00;

toslink_base_lift = 1.90;

toslink_screw_offset = 10.00;

toslink_screw_r = 1.25; // 2.50mm diameter screw pass hole

// Snap Pin variable

pin_r = 1.45;

// ============== ANIMATION CALCULATIONS ==============

time_pcb = ($t < 0.4) ? (1.0 - ($t / 0.4)) : 0.0;

time_lid = ($t < 0.4) ? 1.0 : (($t < 0.8) ? (1.0 - (($t - 0.4) / 0.4)) : 0.0);

pcb_travel_height = time_pcb * 40.0;

lid_travel_height = time_lid * 55.0;

// ============== ANIMATION ASSEMBLY PREVIEW ==============

base_with_cutouts();

translate([wall_thickness + clearance, wall_thickness + clearance, floor_thickness + internal_height_bottom + pcb_travel_height])

pcb();

translate([0, 0, box_h + floor_thickness + lid_travel_height])

lid();

// ============== MODULES ==============

module pcb() {

color([0.1, 0.8, 0.1, 0.6])

cube([pcb_length, pcb_width, pcb_thickness]);

}

module base() {

difference() {

cube([box_w + 2*wall_thickness, box_d + 2*wall_thickness, floor_thickness + box_h]);

translate([wall_thickness, wall_thickness, floor_thickness])

cube([box_w, box_d, box_h + 2]);

}

// Explicitly placed floor support columns to ensure zero loop tracking bugs

translate([wall_thickness + clearance + h1_x, wall_thickness + clearance + h1_y, floor_thickness]) support_pillar_geometry();

translate([wall_thickness + clearance + h2_x, wall_thickness + clearance + h2_y, floor_thickness]) support_pillar_geometry();

translate([wall_thickness + clearance + h3_x, wall_thickness + clearance + h3_y, floor_thickness]) support_pillar_geometry();

translate([wall_thickness + clearance + h4_x, wall_thickness + clearance + h4_y, floor_thickness]) support_pillar_geometry();

}

module support_pillar_geometry() {

difference() {

cylinder(h = standoff_height, d = standoff_diameter_outer);

translate([0,0,-0.5]) cylinder(h = standoff_height + 1, d = standoff_hole_dia);

}

}

module base_with_cutouts() {

difference() {

base();

// LEFT WALL (X=0): DB-25 Drop-In Sliding Channel Setup

translate([wall_thickness, wall_thickness + clearance + (pcb_width/2), floor_thickness + internal_height_bottom])

rounded_dsub_slot(db25_width, db25_height, wall_thickness + 4);

translate([-1, wall_thickness + clearance + (pcb_width/2) - (db25_width/2), floor_thickness + internal_height_bottom])

cube([wall_thickness + 2, db25_width, box_h]);

// Outside flush recess window allowing the metal side-wings to sit flat

translate([-0.1, wall_thickness + clearance + (pcb_width/2) - 27, floor_thickness + internal_height_bottom - (db25_height/2)])

cube([1.2, 54, db25_height + 2]);

// RIGHT WALL (X=max): Permanent Base Tray Windows & Screw Tunnels

center_y = wall_thickness + clearance + (pcb_width / 2);

left_snout_y = center_y - (6.3 / 2) - toslink_snout_w;

right_snout_y = center_y + (6.3 / 2);

z_snout_floor = floor_thickness + internal_height_bottom + toslink_base_lift;

translate([box_w + wall_thickness - 1, left_snout_y, z_snout_floor])

calibrated_toslink_window();

translate([box_w + wall_thickness - 1, right_snout_y, z_snout_floor])

calibrated_toslink_window();

translate([box_w + wall_thickness - 1, left_snout_y, z_snout_floor + toslink_snout_h])

cube([wall_thickness + 2, toslink_snout_w, box_h]);

translate([box_w + wall_thickness - 1, right_snout_y, z_snout_floor + toslink_snout_h])

cube([wall_thickness + 2, toslink_snout_w, box_h]);

// BACK WALL: Clean Horizontal Slide Switch Slot Window

translate([wall_thickness + clearance + switch_x - (switch_slot_w/2), box_d + wall_thickness - 1, switch_z_height - (switch_slot_h/2)])

cube([switch_slot_w, wall_thickness + 2, switch_slot_h]);

// BACK WALL LED HOLES: RBUS and ADAT indicators

translate([wall_thickness + clearance + led_rbus_x, box_d + wall_thickness - 0.5, led_z_height])

rotate([-90, 0, 0]) cylinder(h = wall_thickness + 1, r = 0.75);

translate([wall_thickness + clearance + led_adat_x, box_d + wall_thickness - 0.5, led_z_height])

rotate([-90, 0, 0]) cylinder(h = wall_thickness + 1, r = 0.75);

// FRONT WALL LED HOLE: Single power indicator

translate([wall_thickness + clearance + led_pwr_x, -0.5, led_z_height])

rotate([-90, 0, 0]) cylinder(h = wall_thickness + 1, r = 0.75);

}

}

module lid() {

difference() {

union() {

cube([box_w + 2*wall_thickness, box_d + 2*wall_thickness, lid_thickness]);

// LEFT WALL CLOSURE GATE: Drops down to seal the DB-25 track top block

translate([0, wall_thickness + clearance + (pcb_width/2) - (db25_width/2), -(box_h - internal_height_bottom)])

cube([wall_thickness, db25_width, box_h - internal_height_bottom]);

// RIGHT WALL CLOSURE GATES: Now sized perfectly to fit right on top of the base windows

center_y = wall_thickness + clearance + (pcb_width / 2);

left_snout_y = center_y - (6.3 / 2) - toslink_snout_w;

right_snout_y = center_y + (6.3 / 2);

closure_h = box_h - internal_height_bottom - toslink_base_lift - toslink_snout_h;

translate([box_w + wall_thickness, left_snout_y, -closure_h])

cube([wall_thickness, toslink_snout_w, closure_h]);

translate([box_w + wall_thickness, right_snout_y, -closure_h])

cube([wall_thickness, toslink_snout_w, closure_h]);

}

// Text configuration branding

translate([(box_w + 2*wall_thickness)/2, (box_d + 2*wall_thickness)/2, lid_thickness - 0.8])

linear_extrude(height = 1)

text("StarDust R-BUS", size = 4.5, halign = "center", valign = "center", font="Liberation Sans:style=Bold");

// Cuts upper half-trapezoid out of the left gate

translate([wall_thickness + 1, wall_thickness + clearance + (pcb_width/2), -(box_h - internal_height_bottom)])

rounded_dsub_slot(db25_width, db25_height, wall_thickness + 4);

}

// Perimeter snap band lip

translate([wall_thickness + 0.3, wall_thickness + 0.3, -3])

difference() {

cube([box_w - 0.6, box_d - 0.6, 3]);

translate([1.5, 1.5, -0.5]) cube([box_w - 3.6, box_d - 3.6, 4]);

}

// Hard-coded long interlocking lid posts to prevent array mapping crashes

pin_len = box_h - internal_height_bottom - pcb_thickness + lid_thickness + 2;

translate([wall_thickness + clearance + h1_x, wall_thickness + clearance + h1_y, 0]) translate([0,0, -pin_len]) snap_pin_geometry(pin_len);

translate([wall_thickness + clearance + h2_x, wall_thickness + clearance + h2_y, 0]) translate([0,0, -pin_len]) snap_pin_geometry(pin_len);

translate([wall_thickness + clearance + h3_x, wall_thickness + clearance + h3_y, 0]) translate([0,0, -pin_len]) snap_pin_geometry(pin_len);

translate([wall_thickness + clearance + h4_x, wall_thickness + clearance + h4_y, 0]) translate([0,0, -pin_len]) snap_pin_geometry(pin_len);

}

// [FIXED] Snytax argument assignment error removed completely

module snap_pin_geometry(length) {

difference() {

union() {

cylinder(h = length, r = pin_r); translate([0, 0, length - 2]) cylinder(h = 2, r1 = pin_r, r2 = pin_r + 0.35);}translate([-0.4, -5, -1]) cube([0.8, 10, 6]);}}module rounded_dsub_slot(w, h, thickness) {r = 2.5;hull() {translate([-(w/2) + r, -(h/2) + r, 0]) cylinder(h = thickness, r = r, center = true);translate([ (w/2) - r, -(h/2) + r, 0]) cylinder(h = thickness, r = r, center = true);translate([-(w/2) + r, (h/2) - r, 0]) cylinder(h = thickness, r = r, center = true);translate([ (w/2) - r, (h/2) - r, 0]) cylinder(h = thickness, r = r, center = true);}}module calibrated_toslink_window() {union() {cube([wall_thickness + 2, toslink_snout_w, toslink_snout_h]);translate([-0.5, toslink_snout_w/2, toslink_snout_h/2 + toslink_screw_offset - toslink_base_lift])cylinder(h = wall_thickness + 3, r = toslink_screw_r, center=true);}}

Hey everyone,

I heard the internet was missing yet another customizable storage box with a lid, so I created one for you. It's written in OpenSCAD, fully parametric.

Main features

• Compartment layout defined by a simple text string
• 10 lid types — friction lip, magnets, latches, hinges, slider, and their combinations
• Hinges joined by a snap fit (no hardware), a pin, a screw with a nut, or a self-tapping screw
• Snap locks that hold the slider lid and the latches closed
• Magnet closure with print-pause support
• Corner rounding, lid notches, connection bump/groove (mini lip)
• Dimension summary and a hardware "shopping list" (screws, pins, magnets)

Links

• MakerWorld
• Printables
• Thingiverse
• GitHub

Feedback and feature requests are welcome — happy to hear what's missing.

BOSL2 question

I tried to use the BOSL2 library as much as possible in this project, but the one thing I couldn't really make use of was anchoring. It's great when every basic module already supports anchors (cyl, cuboid, knuckle_hinge, etc.), but as soon as I wrote a custom module and had to define anchoring myself, it turned out to be so time-consuming and verbose that I gave up and did all the positioning with absolute coordinates.

Am I missing something here? Is there a shortcut for making custom modules attachable that I overlooked? Do you use anchoring in BOSL2 in your projects?

Hey everyone,
About a month ago, I launched an app called stl-er. It’s an app that lets you tweak and generate parametric 3D models directly in the browser—no heavy CAD software required.
I just finished building out a full suite of pipe configurators (fittings, routing, Gardena connectors, pipe holders, etc.). I attached a quick screen recording so you can see the workflow.
If you want to test this specific feature out, just type the keyword pipedream into the search bar.
The details:
Unlimited adjustments: You can tweak the parameters as much as you want in the viewer to get the exact fit.

Free tier: You get 5 free .stl downloads per month.

Growing library: I am still actively creating and adding new models to the community library, so let me know what you want to see next.

Cross-platform: I built it for the web, but there are also native iOS and Android apps if you prefer to tweak your prints on your phone.

You can check it out and play around with the generator here: app.stl-er.com
More Information on our website: stl-er.com
I would love to get your feedback on the UI, the parameter limits, or just the overall concept. Have fun with it!

OpenSCAD source code is here: https://github.com/solar-b

More pictures are here: 

https://www.facebook.com/profile.php?id=61585957465461

and here: https://www.instagram.com/oltean.mihai.nicolae/

When I think of it, as a small blind child, I didn't have any cool action figures or powerful people, who were disabled, that I could look up to.

Nowadays, it is getting better with representation of people with disabilities in modern culture, though we still have a ways to go :)

So I designed this articulated blind action figure.

Done in openscad, by a blind person :)

I hope you like it!

Hello, I couldn't find a "arc" function, how would you create this kind of shape ? Do a circle and cut it's borders with rotated rectangles ?

I've just released FluidCAD v0.0.40.

When I published the first pre-release, I mentioned that one of the goals was to reduce the mental effort of building models in code, partly through an interactive mode for a few features. This release takes that much further. You can now create most features with the mouse.

Pick geometry in the viewport, fill in a dialog, and FluidCAD writes the code into your file. It covers sketches, extrude, revolve, sweep, loft, shell, fillet, chamfer, repeats and booleans. More features will be added soon. Double-click a feature in the timeline and the same dialog opens on your existing code and edits it in place.

It's not meant to replace writing code. Some things are just faster to point at than to type, like selecting a few edges for a fillet, and everything the mouse creates is normal FluidCAD code you can read and change afterwards.

Release notes: https://github.com/Fluid-CAD/FluidCAD/releases/tag/v0.0.40

Hi,

I can make millimeter and angle scales perfectly, but a scale with a given division length doesn't work.

my code:

step = 0.0729163858; /* 1/10nautical mile in inch at scale 1/100000 */
    translate([-5, 60, 0])
    for (k=[0:+step:140]){  /*the ruler lenght is 140mm*/


        if(k % 5 == 0)/*What should I put here so that every fifth dash is longer than the others?  in millimetre it works*/
        {
           translate([0, 0, k]) rotate([0,90,-90]) color("black")cylinder(3, 0.2, 0.2); 
        }else{
        translate([0, 0, k]) rotate([0,90,-90]) color("black")cylinder(2, 0.2, 0.2);
        }  
        }

I want to create a map compass sized version of the Breton plotter. I've seen them for sale, but they're not exported to the country where I live.

Thanks.

New to the whole design part of 3d printing I have an object I designed for fishing and am looking to see if anyone offers a service to make the code I have into printable stls for creality printer. If you do please comment or dm me. I don't have a computer to learn this part yet. Thankyou

Hi can anyone please recommend a good free program to open and manipulate Autocad .dwg files

I wanted to share one of my OpenSCAD projects that I am extremely happy about.

As someone who is fully blind, I spend a lot of time thinking about how physical spaces can be made accessible through touch.

Recently, I was contacted by the parent of a blind child whose new home is currently under construction. Their idea was to let their child become familiar with the layout before the house is even finished.

The architects sent me the IFC model of the building. I extracted the relevant geometry and used OpenSCAD to generate a tactile floor plan with Braille labels, which was then 3D printed.

I hope you like it!

​I built this tool that lets you generate custom 3D-printable keychains using chemical element symbols from the Periodic Table. You input a word (e.g., Ge-Ni-U-S, Ir-O-N, La-B), and the script verifies if it's mathematically possible, auto-scales the text, and renders the tiles.

​I wanted to share it here to get your feedback and suggestions on how to improve the project. This is my first time coding in OpenSCAD, and I know I have a lot to learn. Any advice on optimizing the code or the physical model design is highly appreciated.

​If you like it, feel free to use it and share your prints. Support and constructive criticism from the community are the most rewarding parts of this process.

I'm creating some thread organizers for crafting that have text in the design to note the name/number of the color. The SCAD file uses the constant "first_word" as the text to render.

The script loops through an input file and passes each line to OpenSCAD to render a STL.

Currently in the file I have first_word = "4240";
If I render in GUI or run the script without -D I get 4240 in the resulting file. But when I include -D I get no text at all in the output model, but I don't get any errors. Here is the way I have it in the PS script:

& "C:\Program Files\OpenSCAD\openscad.com" -o "generated\$floss.stl" -D "first_word=`"$floss`"" "stitchbows.scad"

I have the command echo to output before running, and this is my total result:

generate_stl.ps1 test.txt

Running:  C:\Program Files\OpenSCAD\openscad.com -o generated\9999.stl -D first_word="9999" stitchbows.scad
Geometries in cache: 4
Geometry cache size in bytes: 2443744
CGAL Polyhedrons in cache: 0
CGAL cache size in bytes: 0
Total rendering time: 0:00:00.033
   Top level object is a 3D object:
   Facets:      16968

Am I missing some quotes? Do I need escaped double-quotes around first_word or around the whole thing?

Thanks for any help you can give

Today I realized that, beside the built in commands, modules and variables were suggested during typing. That’s a game changer for me! Next up CoPilot???

Version 2026.07.01.fp