Category Archives: Software

Tutorial Tuesday 8: Using Sculptris to 3D Model With “Digital Clay”

If you want to make an organic-looking sculpted character head or body, and you want to do it for free, then you’ll want to know how to use Sculptris. Sculptris is a free beginner 3D digital sculpting program made available by Pixologic, the company that produces the professional-grade sculpting software ZBrush. It’s very easy to learn how to use Sculptris to create complex 3D models by pushing, pulling, and stretching a digital ball of clay.

Video Tutorials

For a nice introduction to the basic tools, plus a walkthrough showing how to create character heads, check out the Sculptris Reference Tutorial video by IntroducingEmy.

To dig in even deeper, try watching these three in-depth video lessons that Mr.Brooks made for his students: Becoming Familiar With Digital Sculpting in Sculptris, Using the Grab, Scale, Rotate, Draw, Crease Brushes in Sculptris, and Using the Flatten, Inflate, Pinch, and Smooth Brushes in Sculptris.

For even more Sculptris resources, dive into the extensive Sculptris Jumpstart resource page on Thingiverse, and the video resources on the main Sculptris site.

Sculptris Models on Shapeways

Here are three fantastic Shapeways models that were designed with Sculptris. First, a beautiful Dragon Wall Hook by Kai Bracher:

Next, an elegant and mysterious Woman bust by oekart:

Finally, a scientifically intricate Honey Bee model by PeterAndrew (with wings made in ZBrush).

Have you created any models with Sculptris? Let us know in the comments. We love to hear how different designers are using sculpting software, from free programs like Sculptris to commercial software like ZBrush.

Finally found Waldo? Check out Hidden Folks, a game from community member Sylvain Georget


Our community is a giant melting pot of creative designers, where 3D design is only a fraction of what the designers, makers, engineers and creators are capable of. A while back we celebrated the Academy Award nomination of Alienology, and today we want to highlight community member Sylvain Georget (visit his Shapeways shop Tegroeg), as he took his extreme detailed drawing skills to the next level by launching his own video game Hidden Folks today.

Hidden Folks is an interactive search-find-and-click game. At first, the concept might remind you of Where’s Waldo, but Hidden Folks has much more to offer. The miniature landscapes you’ll navigate through have many funny elements you can control by simply poking. Open tents, slam doors, poke crocodiles — there is so much to explore, we recommend you try it yourself. What really defines this game (besides the hilarious sound effects) are the amazing black-and-white graphics, all hand-drawn by Sylvain. Don’t let the minimalistic look of the game fool you; the world of Hidden Folks is rich in an insane amount of small but great detail — and gimmicks.

Sylvain has been drawing miniature worlds for quite some time, and he’s translated some of them into 3D to sell in his shop Tegroeg.

13 House by Sylvain Georget

House 7 by Sylvain Georget

During the past years we’ve had the pleasure of collaborating with Sylvain a bunch of times, in projects for Dutch Design Week and KunstVesting Heusden, plus we printed his designs for STRP-Festival 2015, and Sylvain even attended the official Eindhoven Factory Opening event back in 2014. Seeing Sylvain use his detailed drawing skills for a whole new platform is truly inspiring.

Sylvain, congratulations to you and Adriaan de Jongh in bringing Hidden Folks to life — we can’t wait to play again!


What if Bob Ross Taught 3D Design?

That soothing voice, those happy little trees, that simple adding of elements that are more than the sum of their parts — it can only be Bob Ross. And, just as Bob Ross loved to share the joy of painting, we LIVE to share the joy of 3D printing. So, we asked ourselves, “What if Bob could teach us 3D design?” Then, we looked hard at our Community Manager Andrew Thomas, squinted, and realized: he’s basically the Bob Ross of 3D design. That gentle voice, those mad 3D modeling skills. A wig, a Wacom Intuos4, a free download of MagicaVoxel, and a few hours later, we had launched The Joy of 3D Design With Andrew Thomas.

Check out the first episode below, and don’t miss Uncubed’s awesome feature on the making of The Joy of 3D Design. Then, all you have to do is subscribe to our YouTube channel, and let The Joy of 3D Design take you away….

How Does a Microbiologist Turn Into a Jeweler?

Today’s guest blog comes from Gabriel Guzman of 3D to the 3e. Gabriel, a professor of microbiology and a jewelry designer, has found a perfect way to combine his passion for science with a love of design. He lets us in on how his Crochet Pendant went from concept to reality — and helped him go from scientist to designer.


Designer Gabriel Guzman’s Crochet Pendant and Earrings

To me, a biochemist and a microbiologist, the design process for 3D printing has a lot in common with designing an experiment in the lab. First there is a general idea that generates a possible solution — a hypothesis. Then there is the use of design tools to shape that idea into something printable. And, of course, continuous prototyping to explore different versions of the design. Finally, one of the iterations will have the aesthetics, balance, and curiosity, if you will, that might make somebody ask, “How did you do that?”

When I first began to design the Crochet Pendant, I did have a pendant in mind, but the final design didn’t emerge until after I played with a number of different iterations. The name, however, came after looking at the final design — and a crochet piece that I saw on a table. My mother used to have a lot of doilies and other table covers made with crochet.

In terms of the technical design process, I was getting my hands wet with an experimental app from Autodesk called Project Shapeshifter, which allowed for the creation of generative designs. Generative design is a method in which the final model is generated by a computer program following a set of rules or an algorithm. I started with a general shape that I had in mind, but I didn’t know what I would end up with in terms of the final object. So, I tested different parameters in Shapeshifter, until one of the many iterations had everything I wanted to see in the pendant.

I began with the idea of a circular object, with details based on the repetitive pattern of a honeycomb. Shapeshifter only generated the file to be printed, but a pendant needs a loop, a bail, or something to pass a chain through. I chose Tinkercad for that purpose because the software was free and easy to use. I designed a very simple loop, which wasn’t circular but followed the shape of the pattern, and the end result was a piece that has generated a lot of comments, but more important, a piece that I was satisfied with. Perhaps the most important lesson for me is that none of my finished designs are exactly as I first imagine them, and they really don’t have to. Every finished design is a result of tweaking, and rethinking possibilities.

The reaction from people, especially if they don’t know anything about 3D printing, is of amazement that a machine can make jewelry. The metal version of the pendant didn’t happen until about three months after I printed the first version at home in a mint-colored plastic. My wife wore the pendant during that year’s commencement ceremony and my colleagues kept asking her about the piece, and then kept asking me about how it was made. I never imagined that a piece made in plastic could draw that much attention!

For those with experience designing jewelry the old-fashioned way (by sculpting wax), they recognize what 3D printing technology can do for their own creativity. It helps them go beyond the traditional wax sculpting into digital sculpting. But, for the novice, this technology is also a way to democratize art. Perhaps the most common question I get is, “How does a microbiologist turn into a jeweler?” If people consider me a jeweler, I take that as a big compliment! After all, I didn’t go to art school, although I do have some background in graphic design, but I never fancied myself a jeweler until I began experimenting with 3D printing.

CAD vs. Modeling: Which 3D Software to Choose?

One of the most common questions we get from those who are new to digital manufacturing is “If I want to design something, which software should I learn?”

The answer to that is a little complex, but it hinges on one simple idea: What are you trying to make? There are lots of great software packages for 3D design out there, each tailored to a different type of product design. Knowing what you are trying to make will dictate the type of software you will use.

Overall, design software falls into two camps: CAD and 3D Modeling. CAD software is used when creating industrial, mechanical objects. Alternatively, 3D modeling packages more commonly used for making organic elements used for film special effects and video games.

Depending on the goals of your design, you may use both types of software at different stages of the design process to make the final 3D-printable design.

Below, we’ll go over how they are different and provide a few examples of each software type.


CAD (Computer Aided Design/Drafting)

CAD programs ask the user to “draw” a 2D shape and then turn those drawings into 3D forms, as either solids or surfaces. Drafting software comes from a long lineage of product designers, architects and engineers who would draw 2D plans, complete with measurements, which would be handed over to technicians or craftspeople who would interpret the designs and make the said object. This could be done manually or with a successive process of machining. Nowadays we have tools like 3D printing so that the design can be interpreted by other software (CAM or Computer-Aided Manufacturing) to create the tool path or slicing for 3D printing.

CAD programs take these 2D drawings and digitally translate them into 3D rendered “objects.” In some cases these are just “shells” or surfaces, while other programs treat the object as mathematically solid material. Simple shapes can then be added or subtracted to create more complex forms.

Because CAD software takes its roots in 2D drafting it is mainly for functional, measured 3D objects. Any functional object around you (your phone or computer that you’re reading this blog on) was designed in CAD software.

Examples of CAD:

Solidworks: Industry standard CAD software


Fusion 360: Free for students, startups, and makers!


Tinkercad: great for beginners


Onshape: Cloud-based with free option


3D Modeling

CAD software is great for functional objects, things that need to work mechanically or fit to a real world device. That said they may not give direct enough control over a design to allow for freeform, artistic work. This is where 3D modeling software comes in. Long used by the film and video game industry to make animation and special effects, you can also use these programs to create printable 3D models.

Modeling softwares are based around surfaces created from 3D geometry. This may be based around a system called NURBS, or may be simple polygons composed of vertices, edges, and faces. In many cases, programs will let you switch between these systems with ease, depending on your workflow. These points and surfaces come together to form the edges of a 3D object.

The advantage of modeling over CAD is that modeling software gives users direct input into each vertex or surface individually or as groups. This always for different ways to manipulate the shapes, often in ways that look more organic.

Some programs are even designed to treat 3D models as if they were lumps of clay so that designers can take a more sculptural approach. Using tools that emulate traditional artistic techniques, artists can get the most out of the geometry of a digital object.

Examples of 3D modeling software:

Sketchup: Free and popular


Maya: Industry standard for film and animation


Blender: Free, open source, and runs some of Shapeways’ backend tools


ZBrush: Professional digital sculpting software


Sculptris: Simpler, free version of ZBrush for beginners

Overall, knowing what you want to achieve with your design is vital to choosing the right tool for you. If a design needs to be functional, fit to other real-world objects, or have specific measurements, starting with CAD is the way to go. If a design needs to emulate a real-world or imaginary object or showcase your artistic vision, modeling could be a solution. If a design wants to do both, try mixing and matching software within your process.

Learn ShapeJS: Signet Ring

I’m really excited about this weeks post. Not only did the test prints come out well but as a creator concept I really think this idea has legs. We published the ring creator a few years ago and the response and sales have been very favorable. Looking through the designs people make it’s clear that signet ring type usage is desired. ShapeJS has had a signet ring example for awhile, but for this posting I improved it with side images and engraved text. In terms of new ShapeJS concepts we’ll go over Text,Embossing,Mul and Mask.

Let’s start with a photo of the first test rings. These are with the text engraving but not the side images. The user gets to choose the top imagery, the engraved text plus the typical ring size and width.

Originally I had the image go completely through the ring. For this revision I changed to having the image engraved. We are working up to having shopper friendly creators available and we found that explaining when pieces would fall out was difficult. Engraving the top allows you to ignore that problem and there’s never a question whether it will be structurally sound. Here is a picture of the original style:

How would you go about modeling this ring style? The primary area of interest is the top image area. We want a flat area that blends nicely into a band. Let’s start with a Cylinder slice as the top area. This gives us a circular landing area. Here is a diagram showing the setup we’ll use.

We made the height of our image area(called a bezel) 1.5mm. This gives a nice feeling weight to the ring and insures that we have enough space to engrave at least 0.35mm deep as required by the guidelines for polished metals. The next part we’ll do is cut the cylinder with two planes at an angle. This gives us something more interesting then just a straight sided cylinder. Here is the code for this portion:

  // bezel is cone truncated by 2 parallel planes
  var bezel = new Intersection();
  bezel.add(new Cone(new Vector3d(0,Ay, 0), new Vector3d(0,-1,0), bezelAngle));
  bezel.add(new Plane(new Vector3d(0,1,0), bezelTop));
  bezel.add(new Plane(new Vector3d(0,-1,0), -bezelBase));

Now let’s turn towards getting the band correct. For this we’ll start with a Sphere(ringBase) which will be a radius of ring size + the ring thickness. From this sphere we’ll cut out a cylinder for our finger(thru). Then we’ll use the combination of a cylinder and box to create the arch like shape on the sides(cutoff). The final band will be the base sphere plus the bezel that we then subtract the finger thru hole and the side cutoffs.

  var ringBase = new Sphere(outRad);

  var ring = new Union();

  var cutoff = new Union();

  var gw = gridWidth;
  var gw2 = gridWidth/2;
  var thru = new Cylinder(new Vector3d(0, 0, -gw2),new Vector3d(0,0,gw2),inRad);

  cutoff.add(new Cylinder(new Vector3d(-gw2, Ey, Ex), new Vector3d(gw2, Ey, Ex), cutR));
  cutoff.add(new Cylinder(new Vector3d(-gw2, Ey, -Ex), new Vector3d(gw2, Ey, -Ex), cutR));
  cutoff.add(new Box(0,-inRad,  Ex,  gw, 2*(inRad+Ey), 2*cutR));
  cutoff.add(new Box(0,-inRad, -Ex,  gw, 2*(inRad+Ey), 2*cutR));

  var partialRing = new Subtraction(ring,thru);

  var fullRing = new Subtraction(partialRing, cutoff);

Now that we have the ring modeled its time to turn to making it more customized. Using user imagery is a great way to add customization. For our signet ring we’ll provide 4 customizations points. We’ll have an image on top, an image on each side and text on the inside of the ring. In the past we’ve learned about the Image3D datasource. These easily turns images into 3D geometry. This is great for when we have flat areas to place things or a simple curve like a cylinder. Things become more tricky when we want to apply imagery to complex or unknown shapes. When dealing with these you’ll want to use the Embossing datasource. An Embossing let’s you change the surface of an object with another object. If your familiar with displacement maps in traditional modeling packages it’s a similar idea.

An Embossing takes a base shape and then an embossing shape. It also takes a minimum and maximum range value to limit the embossing distance. In general an embossing is only really good close to the surface, usually you wouldn’t extend further then 2*MM from the surface with this. This example also uses another new datasource called a Mask. A mask is used to select portions of a datasource you want to use for an operation. By default an embossing affects all sides of an object within its volume. For our ring this would mean the side images would emboss both the inside and outside. Since we want text inside we need to mask out the inside. We can do this by taking the band as the mask and shifting it to right or left. This creates a masked area on the outside to limit the application of the embossing to that region. Here is the code for left side imagery:

  if (args.leftImage !== undefined) {
    var edepth = ringThickness/4;
    var mask = new Mask(result,0,edepth);
    var maskShift = new Vector3d(1,0,0);
    mask.setTransform(new Translation(maskShift));

    var lbump = makeImage(args.leftImage, 0.84*2*Cx, By+inRad,12*MM,false);
    var trans = new CompositeTransform();
    trans.add(new Rotation(0,1,0,Math.PI/2));
    trans.add(new Translation(inRad,0,0));

    var maskedBump = new Mul(lbump, mask);

    var lsideImage = new Embossing(result,maskedBump);
    result = lsideImage;

Since we are looking to engrave the ring we set the minimum value of the embossing to our desired depth and then maximum value to 0. Now that we have the imagery on the sides we are ready to tackle the engraved text. Text in ShapeJS is basically just like the Image3D node. Internally your specified text string, font and font styles are converted to a raster image. To do this you use the Text2D datasource. You then specify the font name and style you want to use. In a later tutorial we’ll cover how to use custom fonts. Text2D has alignment and centering options for the horizontal and vertical directions. Checking the online docs I can see we need put more detail there, so look for that soon. Here is the final ring:

One note about the image sizes. The side images are mapped to cover the whole side of the potentially largest ring. I used images of 400×667 resolution. Anything following that aspect ratio will work. If you adjust ring width you’ll reveal more of the image on the sides.

This wraps up our signet ring post. We’ve introduced a bunch of new concepts this week that we’ll reuse in later postings. Adding text and imagery to base objects gives your users plenty of options to make things their own. Using 3D printing we can make each object unique and this gives you the power to easily get it done. Here is the full code for your enjoyment:

Signet Ring

Learn ShapeJS: Symmetry and Reflections Part 1

For this week we’ll start into the powerful world of symmetry and reflections. ShapeJS allows arbitrary transformations of objects and as we’ll see in this post this has great power and some sharp edges to avoid. Guest writing this week is Vladimir Bulatov, he’s the math whiz behind the curtains of ShapeJS.

PeriodicWrap is a ShapeJS transformation which is most useful for creating repeated shapes and patterns. However if used incorrectly it can produce unexpected results. The purpose of this tutorial is to provide basic info and examples with correct use of PeriodicWrap, highlight potential problems and suggest possible solutions.

PeriodicWrap generates a fill of the three dimensional space (tiling) with copies of a single tile – the fundamental domain. PeriodicWrap is defined by linearly independent basis vectors and an origin. All parameters have type Vector3d. Basis vectors define the shape and orientation of the fundamental domain and the origin defines the place of the fundamental domain in space. There are 3 variants of PeriodicWrap one-, two- and three-periodic. This week we’ll examine the one periodic version, and in a later post we’ll cover the more complex versions.

One-periodic wrap
We start with the simplest variant – one-periodic. It is defined by one basis vector and origin. The origin has default value (0,0,0) which means the PeriodicWrap is located at the origin of the coordinate axes.

var a = 5*MM;
var pw = new PeriodicWrap(new Vector3d(a,0,0));

This creates a one dimensional PeriodicWrap with basis vector (a,0,0).

The one-periodic tiling can be imagined as cutting a space into set of identical slices. The fundamental domain (yellow) is a single slice. Slices are orthogonal to the basis vector (in this case (a,0,0). The thickness of the slice equals the length of the basis vector (5mm in this case) and the left side of the slice passes through the origin of the PeriodicWrap (in this case default value (0,0,0)). Let’s place a simple shape inside of the fundamental domain.

  var sphere = new Sphere(a/2,a/2,0, a/3); // sphere radius a/3 centered at (a/2,a/2, 0) 

And apply PeriodicWrap to the shape.

  sphere.setTransform(pw); // tiled sphere 

Here is the diagram of the result:

Shapes are replicated in both directions indefinitely. Below is the screenshot of the ShapeJS rendering:

Let’s place a different shape in a different spot

  var redSphere = new Sphere(0,a/3,0,a/2); // sphere radius a/2 centered at (0,a/3,0)

PeriodicWrap works by filling the whole space by identical copies of single tile – the fundamental domain.The interior of the fundamental domain is replicated. Parts of the shape outside of fundamental domain are cropped. It means, that the half of sphere sitting outside of fundamental domain abruptly disappears.

The rendering looks even worse, the cropping induces severe rendering artifacts

There is a simple solution to the problem. We can shift the origin of the tiling to make a shape enclosed by the fundamental domain

  pw.setOrigin(new Vector3d(-a/2,0,0));

And here is the tiling

The rendering now looks correct as well

But it is not always possible to select a good location for the tilings origin. In example below we have a union of two shapes.

The union doesn’t fit inside of fundamental domain. Therefore the shape always will be partially cropped:

The solution to the problem is to build a shape inside of the fundamental domain in a way which will compensate for unavoidable cropping: the opposite sides of fundamental domain have to pair seamlessly to each other. In this case we can place copy of another red sphere translated by the tiling basis vector (a,0,0)

Here are the drawing and rendering of the resulting tiling:

Complete ShapeJS script of the example with two shapes:

function main(args) {	
  var w = 30*MM; // scene size
  var a = 5*MM; // period of wrap 
  var s1 = new Sphere(a/2, a/2, 0, a/3);  // shape 1
  var s2 = new Sphere(0, 0.7*a, 0, a/2);  // shape 2
  var s2t = new Sphere(a, 0.7*a, 0, a/2); // translated shape 2
  var pw = new PeriodicWrap(new Vector3d(a,0,0));  
  var shape = new Union(s1, s2);
  return new Scene(shape,new Bounds(-w,w,-w,w,-w,w));

After a PeriodicWrap transform is applied to a shape inside of the fundamental domain we normally obtain an unbounded shape. That shape intersects the scene bounds and as result has an open interior, which results in manifold problems in the generated mesh as is shown below with red.

In order to obtain a finite shape of specific size, we may intersect unbounded shape with some shape of specific size, for example a box:

shape = new Intersection(shape, new Box(55*MM, 20*MM, 20*MM));

PeriodWraps are a powerful method for creating many copies of your geometry. It’s also a much more efficient way to create lots of shapes instead of copying the datasources. In our next posting on symmetry and reflections we’ll explore the two and three periodic wrappings. These allow you to create some interesting patterns, similar to what you might find in nature. As a taste here are some two and three periodic wrappings:

Learn ShapeJS: Coins

On tap for this week we’ll print our own coinage. Don’t tell me you haven’t secretly wanted your own currency! When we first introduced cast metals it was one of the first projects I thought of. Here are the first tests I’d did:

These came out well, better then I really expected. The detail was amazing, nice weight to them and they sounded right when you flipped them. If your latin is not so good, it says “I scream, you scream, we all scream for ice cream.” Well, maybe it says that, been a long time since latin class.

In terms of what went wrong. I overestimated the height needed so the text it a bit too raised from the base. It doesn’t feel completely right in the hand, more like braille then coinage. Looking more at real coinage they have some edges(called reeds). Adding those cleaned up the sides nicely. Here is the second attempt:

This time I also printed them out in stainless steel as well as the polished metals. Steel has a minimum height of 3mm. The detail is better then I expected and the pricing is certainly nicer. It does however feel a bit heavy for a coin. I also did a test with White Strong & Flexible coins, but I can’t say I really liked them.

You can create your own coins here: Coin Example

This script uses concepts we have mostly already covered, but there are a few more details of the Image3D datasource to cover. The first is the useGrayscale method. The default operation is to assume your image is black and white. Under the covers we process this into a distance transform. We do this so that lower resolution images looks better. For greyscale imagery we can’t do the same operation, we just take your image and use it to define the height. Black represents the highest points and white the lowest. Think of this like your drawing with a black pin, your ink creates 3D geometry, the darker it is the more of it.

The second concept is the image placement options. When we create the geometry from an image it has a few modes. These are based off the setImageType and setImagePlace. The image type says whether we creating an embossed or engraved image. An embossed image has the darkest points going upwards whereas an engraving has the darkest points going downward into the object. The placement options say how the image is placed in the image box. Top placement puts the image in the upper area of the box, bottom does opposite. Both mode has the image in the top and bottom of the box. The following diagram gives a visual reference of the different modes:

Coins are fun way to start into the 3D printed metals. If you create your own coins or improve my script post into the forums and show it off.

Learn ShapeJS: Volume Pattern Ring

For this week’s post we’ll create a ring based on volumetric patterns. In the process we’ll learn about blending in boolean operations and how to make wearable 3D jewelry. So first up, a photo to get you inspired!

The basic idea of this script is to cut a ring out of a volume containing an interesting 3D pattern. We learned about VolumePatterns in our ToothBrush Holder posting. These patterns fill the design space with a controllable pattern generator. We can then use some simple boolean operations to make a ring. We’ll cut the space with two cylinders. The first cylinder is the outer edge of the ring. The second will be the inner edge of the ring. Using a Gyroid pattern we get the following starting pattern:

Here is the code, the cylinder ocutter cuts the space for the outer ring, the icutter cuts it for the inner ring. The sides are then cut using 2 cutting planes.

  var ocutter = new Cylinder(new Vector3d(0,-10*CM,0), 
                             new Vector3d(0,10*CM,0),size+pattern_thick);  
  var icutter = new Cylinder(new Vector3d(0,-10*CM,0), 
                             new Vector3d(0,10*CM,0),size);
  var cutter = new Subtraction(ocutter,icutter);
  var body = Intersection(gyroid, cutter);    
  result = body;
  var fplane = new Plane(new Vector3d(0,-1,0),new Vector3d(0,width/2,0));
  var bplane = new Plane(new Vector3d(0,1,0),new Vector3d(0,-width/2,0));

  result = new Subtraction(result,fplane);
  result = new Subtraction(result,bplane);

  s = ringSizeToRadius(16) + 6*MM; 
  var scene = Scene(result, new Bounds(-s,s,-s,s,-s,s));
  return scene;


One thing you might notice is the pattern has some sharp edges. An issue with jewelry and rings in particular is they need to wear well. No-one is going to like wearing a metal ring with sharp edges. In this example we use two techniques to make the rings more comfortable. The first is to provide a liner in the ring that separates the potentially sharp pattern edges from your finger. By using a cylinder as a liner we a get a known pleasing shape that is easy to match with the requested ring size. This code shows the addition of the liner by adding another cylinder inside. The thickness of the band is specified in the band_thick variable.

  var ocutter = new Cylinder(new Vector3d(0,-10*CM,0), 
                             new Vector3d(0,10*CM,0),size+pattern_thick+band_thick);  
  var icutter = new Cylinder(new Vector3d(0,-10*CM,0), 
                             new Vector3d(0,10*CM,0),size+band_thick);
  var cutter = new Subtraction(ocutter,icutter);
  var body = Intersection(gyroid, cutter);    
  result = body;
  if (band_thick > 0) {
    var oliner = new Cylinder(new Vector3d(0,-10*CM,0), 
                              new Vector3d(0,10*CM,0),size+band_thick);
    var iliner = new Cylinder(new Vector3d(0,-10*CM,0), 
                              new Vector3d(0,10*CM,0),size);
    var liner = new Subtraction(oliner,iliner);
    result = new Union(result,liner);
  var fplane = new Plane(new Vector3d(0,-1,0),new Vector3d(0,width/2,0));
  var bplane = new Plane(new Vector3d(0,1,0),new Vector3d(0,-width/2,0));

  result = new Subtraction(result,fplane);
  result = new Subtraction(result,bplane);

  s = ringSizeToRadius(16) + 6*MM;  // Hardcode to show sizes changes better
  var scene = Scene(result, new Bounds(-s,s,-s,s,-s,s));
  return scene;


The result looks like this:

This is better, but it still contains some sharp edges around the pattern. The second technique is to use a blend on the boolean combination operations. The default operation of booleans such as a Union, Intersection or Subtraction to combine datasources typically create hard edges. Notice how the liner and pattern seem very distinct. A blend allows you to smooth out these transitions. All booleans have a setBlend method you can use to blend the results together. The parameter is in physical units which represents the distance to smooth over. The larger the distance the more smoothing. Here is our ring now with some blending applied.

High Search Space Scripts

I classify these scripts as high search space scripts. There are a lot of non printable and non interesting rings,but buried inside are some real gems. This can be fun but it does make it challenging if you want to expose this type of creator to novice users. ShapeJS will have more tools soon that will help with the printability aspects. For the aesthetics, perhaps we can use some of the new deep learning algorithms to help us understand what looks good. I’m thinking of a user interface that shows you a bunch of random rings, you swipe Tinder style to rate them. It then uses these to train a recognizer of your style. Then it presents you news rings that are more likely to your tastes. Likely a pipe dream currently but could be something in the future. For now we’ll have to assume the user is interested enough to play with the script and find interesting patterns on their own.

Take a look at the Pattern tab on the final creator here:

This tab has several parameters available to travel through the design space. The Period,Thickness and Height parameters control the overall pattern. The Location and Rotation params move the ring geometry to different areas in the pattern. Consider this like driving the pattern around to find the right parking space. The last parameter, Blend let’s you change the amount of blending that’s used. This changes the overall look a fair bit and can also be used to get around some wallthickness issues to remove or thicken small pieces.

A few more pictures to wet your appetite. This is a close up of a printed piece:

And this is a montage of a few different parameter settings. I really like the range of different patterns you can get from this script.

I added this creator to the ShapeJS Examples page, you can find the completed script here: VolumePattern Example.

Learn ShapeJS: Light Switch Cover

This post you’ll learn about how to load triangle meshes into ShapeJS and a method to protect functional areas in your design. Our goal this week is to design a lightswich cover that is customized with a user image. I started this process by finding common measurements of light switches and thinking about how to 3D model it. I quickly got into wanting a script that could handle n toggles, different hole types, phone and audio connectors, it got complicated fast! Then I found some already 3D modeled versions in different model repositories and became lazy. The final form of this script takes a 3D triangle model as its base object and then overlays the user image. Let’s start with a photo of the final object to get us inspired:

To understand how we load 3D models into ShapeJS it helps to understand the internal representation we use. All datasources in ShapeJS calculate a signed distance function. This is zero on the surface of the object, negative inside and positive outside. The function for loading a 3D model from your code is called loadModelDistance. It takes the file name, a voxelSize and the maximum distance to calculate. The voxel size controls the resolution we load the model and how fast it loads. For small models I use 0.1mm, but for something larger like this model I use 0.2mm. For the distance, you want to use a distance out to the maximum place your edit the model. For our light switch cover we’ll be embossing our image up about 1mm so I calculate the distance function to 1.2mm. Think of a cloud surrounding your model, you need this cloud to intersect anything you’ll doing to the model such as adding or subtracting material. You don’t need to be super accurate about this, but the farther out you calculate it, the longer the calculation takes.

Let’s start by just loading the model itself.

var params = [
name: "model",
label: "Model",
desc: "3D Model of light switch",
type: "uri",

function main(args) {
var base = loadModelDistance(args.model, 0.1 * MM, 1.2 * MM);
var bounds = base.getBounds();

return new Scene(base, bounds);

For the basic light switch cover it looks like this:

Currently we support loading STL and X3D files. The X3D files currently ignore the color information and just load the geometry. When you load the model it will return an object with a bounds property. You can use that bounds property to set your scene bounds.

From there we can start adding in the user images. The way I thought about this was to reuse the Image3D datasource. This loads an image and makes 3D geometry out of it. In this case we are going to extrude it up by 1mm. One problem with this concept is it will block the functional areas of our model. In this case we need to protect the two screw holes and the square light switch rocker area. To do this we are going to model the protected areas and then subtract those from the pattern. The makeImage method takes our user image and the makePattern method subtracts out a box and two holes to protect the design.

function makeImage(path, w, h, d) {

var img = new Image3D(path, w, h, d);

img.setBlurWidth(0.2 * MM);
img.setCenter(0, 0, 3.5 * MM);

return img;

function makePattern(path) {
var box = new Box(12.5 * MM, 25.5 * MM, 15 * MM);
var hole1 = new Cylinder(new Vector3d(0, -30.674 * MM, 0), new Vector3d(0, -30.674 * MM, 25 * MM), 5.5 * MM);
var hole2 = new Cylinder(new Vector3d(0, 29.805 * MM, 0), new Vector3d(0, 29.805 * MM, 25 * MM), 5.5 * MM);

var img = makeImage(path, 64.16 * MM, 106.185 * MM, 1 * MM);

var holes = new Union();

return new Subtraction(img, holes);

You can run the full example here: Light Switch Cover Example

I think this design came nice. I also tried it in our Blue material:

One variant I tried was to cut the pattern completely through the original model instead of embossing it. Looking at the 3D model itself I really like this better, plus is was much cheaper. That said I found out quickly that looking inside an electrical box is not the prettiest of things. Seems the original designers had the right idea of covering that stuff up!

Couple of notes about this project. This current script embossed 1mm of material on top of an existing model. The model itself is pretty darn strong printed in plastic, so I feel like adding more material is not necessary. Perhaps engraving the design would work well and cost less. The second note is about costs. I looked around on Etsy and Amazon to get an idea of whether this concept would work. Typically 3D printed items are more expensive then their mass produced cousins. On Amazon I found single light switch covers ranging from 0.25 for a very basic model to $20 for a fancy model. On Etsy they range from $5 to $32. This design costs around $18 currently. I’d say that puts this in the ball park of a good concept that could compete on price and allow the user to create whatever design they want. This method is also applicable to other objects you’d like to put designs on such as a phone case. Take a base 3D model of the case, model the functional areas in the case you want to protect such as the camera and controls and there you go. Instant phone case creator!

Learn ShapeJS: Toothbrush Holder

For this weeks project we’re going to learn a new modeling technique, have some fun with volumetric patterns and then apply these to make a toothbrush holder.

Last week we talked about using 2D imagery as way to create 3D data. We’re going to reuse that technique here but in a different way. In traditional 3D modeling one of the first modeling technique you learn is called a surface of revolution. If you’ve ever played on a pottery wheel or lathe then you’ve seen this technique. Basically you take a profile and turn it around a circle to make a solid. Here we’ll reuse the Image3D datasource to read in a user provided profile. We’ll then use the RingWrap transformation to revolve that profile around a circle.

Let’s take a look at an example. This is the profile we’ll use for the toothbrush holder. For my design I wanted a solid bottom with curved in sides. The profile you see here is basically one half of the object we want. In your mind just reflect the image to the left to imagine what the finished model will look like.

Here is the solid created from that profile:

One important concept in 3D printing is wall thickness. Depending on the strength of the material you may need thicker walls. The thickness of your lines(StrokeWidth in some software) determines how much material your walls will contain. For now we won’t go too deeply into wall thickness but I wanted you to realize that you could change this based on how thick you make your lines.

The ShapeJS code to create this profile looks like this:

function makeShell(profilePath, width, height, voxelSize, blend){
var radius = width/2;
var boxDepth = 2*Math.PI*radius + blend / 2 + 2 * voxelSize;
var boxWidth = radius;
var boxHeight = height;

var image = loadImage(profilePath);
var grid = image.getGrid();
var expandOp = new ExpandOp(0,3,3,3);
grid = expandOp.execute(grid);

var image = new Image3D(grid, boxWidth, boxHeight, boxDepth, voxelSize);

var ct = new CompositeTransform();
ct.add(new Rotation(0,1,0, -Math.PI/2));
// align side of the image box with xy plane
ct.add(new Translation(0, 0, -radius/2));
ct.add(new RingWrap(radius));
return image;

This technique is good for making a bunch of different objects such as vases, candlesticks, and wine glasses. If you pair this with a simple sketching interface that exports an image, you could make a quick authoring tool for making some nice objects. We’ll return to this idea in some later postings.

The next concept to cover is a volume filling pattern. These are regular patterns that fill space infinitely in all directions. They have many uses, not the least of which is the ability to
turn something rather plain into something really interesting. Let’s look at what these patterns look like:

Volume Patterns

The top two patterns are called a Gyroid. The specific features of a Gyroid are interesting but too much detail for here. Wikipedia’s entry has more details if your interested: Gyroid. The two specific examples you see here are the same pattern but with the Period changed. The period parameter determines in what distance the pattern will repeat. So for a gyroid you roughly think of it as how large the holes are. The other parameter is the thickness. Most of these patterns are in theory thin sheets. By adding a thickness parameter we make it possible to give them volume and give you control over how much material is used. The second row of pictures contains the SchwarzP and SchwarzD patterns. Over time we’ll likely add some more interesting patterns.

It’s now time to combine both of these techniques to create a 3D printed object. We first take a user profile to make the basic shape of our object and then we intersect it with a Gyroid to make
the surface more interesting. I added parameters to help you control the volume pattern and move the object through the volume space. Another useful control is the Blend parameter. This affects
how round or flat things look like and really changes the feel of the object.

Here are some examples using different volume patterns and parameters:


Now that we have some good models being created from our script its time to start printing them. A common practice if you have a 3D printer is to prototype the print in the cheapest material you have available. I have a small FDM printer at home so I choose to print it out using that. Since i only have one printer extruder I had to use the same material for supports and the main item. After a long session of removing supports I got to hold my first version. Success! Sadly, the supports left some tool marks but all in all, I was happy with my first version.

FDM Print

In an ideal world, I would of designed my object to not require support material. But that can be a tough problem. Instead of doing that I decided to switch materials to the SLS Nylon material offered at Shapeways. The built object sits on a bed of powder while printing so it doesn’t require any support material. The second version of my print looks like this:

SLS Print

A few design notes from this project. After trying it out a bit as a real toothbrush holder I’ve decided that having a top lip would be a nice feature. Depending on how the pattern intersects at the top you can get some pretty big crevices which the brushes like to fall into. For the final script I added a top and bottom rim option which you can use to line the shapes. I decided not to use the bottom rim as I wanted the water from the brushes to flow out.

Top Rim

The last note is I would recommend sealing these prints with something to keep them clean. If the material you use is somewhat porous(most are) then eventually you’ll get toothpaste stuck too it. I applied a coating of Krylon Crystal Clear which is an acrylic coating to seal the material. I’m hoping this makes my holder last a long time and makes it easier to clean when needed.

That wraps this week’s Learn ShapeJS posting. We covered a lot of ground today, you learned a new modeling technique and delved into the fun world of volume patterns. If you make something cool with this script please share your experiences in the ShapeJS forums. I almost forgot! Here is the example script for you play with: ToothBrush Holder

Learn ShapeJS: Image Poppers

For our first foray into learning ShapeJS, we’re going to start by using 2D Images. Millions of people already know how to use 2D image tools, so if we can leverage those skills for 3D modeling we’re in business.

The advantages I see in using 2D source material are:

  • Millions of 2D capable artists compared to much fewer 3D artists
  • Easy to source free material on the internet
  • Easy to purchase high-quality assets
  • Sketching interfaces are fun and intuitive for many


Image Popping

The basic concept is to use a 2D image as the source to create 3D data. You specify the physical dimensions of the base and the 2D image is extruded into the Z direction. The image of the letter R on the left creates the 3D object on the right. This is the basics of what I call Image Popping. You pop the image up into the third dimension.

Image to 3D

The complete docs for the Image3D datasource are available here: See Image3D.

So now that you can use imagery in ShapeJS let’s think about what can be made with it. The first object that came to mind for me was a pendant. By simply adding a loop or a bail/connector to the top of a 2D image, you have a quick and easy 3D jewelry project. This is the basis for the Pendant Creator, one of our 2D-friendly design apps, which is a popular first creator for those new to 3D printing. You can use our pendant creator here: Pendant Creator

My First Pendant


That project went well, so I decided to try my hand at something dear to my heart: books! This time I conned a friend into sketching some crystal-like patterns and used that as the source material to pop up a bookmark.



That was fun, but my friends rightly pointed out that I could have done that project with a laser cutter. Now I’m sad. Looks like I need to up my making game. The next level of image popping is to transform the image in some way. All ShapeJS datasources can take a Transform via the setTransform() method. A transform is a function which maps an object to a new version of itself and can significantly change a datasource. A simple transform, called a Translation, is used to move and object around in space, i.e. to move an object one unit to the right, you say new Translation (1,0,0). Other transforms can rotate and scale (change size of) an object. A more advanced transform that I commonly use is the RingWrap transform which wraps the image around a cylinder. This allows us to easily use an image to create a ring or bracelet. We used this in our Ring Popper Creator. Here are some printed examples we’ve done using that technique. The top is the printed object and the bottom is the source image used.


It’s pretty simple to make. You just load an image and then use the RingWrap transformation to bend it around a cylinder the size of your finger. This technique is good for making rings. If you want to make a bracelet out of it then you might want to use another transform called Scale. A scale transform changes the dimensions of an object in any direction. For your wrist you’ll notice that it’s really a squashed shape not an exact cylinder. This example takes the ring example and resizes it for your wrist with a slight scale to make it fit better: Bracelet Popper

Tiling and Symmetry

Our final example for image popping will takes us into some interesting places. Perhaps you’ve seen the cool art done by Arabic artists. Think of Alhambra, or more modern, the work of Escher. These all use tiling and symmetry patterns to make complex and pleasing patterns. Personally I’m not a great 2D artist so I find it difficult to fill an entire canvas with interesting designs. One way to get around this is to take a simple element and then transform it around your space. ShapeJS has an extensive set of support for tiling and symmetry. A later blog post will go into much greater depth but I wanted to end this post with an example that I hope inspires you. Using a single image we can tile that around a sphere. This is called an Icosahedral Symmetry and it looks like this:

Icosahedral Reflections
By Tomruen at en.wikipedia


The lower corner of your image is reflected around the sphere. You get 120 copies of your image rotated into different orientations. This makes for some really cool patterns from simple images. Here is an example I made into a tea light:


You can try out this example here: Tealight.js

Using this same technique we can also make something like a candy dish. The dish is made by keeping the lower quarter of the sphere and then a base is added to make it stable.

Soap Dish

You can try out the Candy Dish example here: Candy Dish Example

2D Images make a powerful starting point for creating 3D models. ShapeJS makes it easy to use images as the source material for some fun projects. Hopefully this blog post has inspired you to create your own objects using the Image3D datasource and some simple transformations. If you have questions about ShapeJS please join us in the forums: ShapeJS Forum

Introducing the 3D Manufacturing Format

Screen Shot 2015-04-30 at 11.12.49 PM

You may have heard the news that a new 3D Manufacturing Format (3MF) was announced recently at Microsoft Build. We’re excited to have a part in this news and wanted to come here to tell you more about it. The announcement today was in regards to the 3MF Consortium we are a part of. Seven leading companies in the global 3D printing sector have come together and will release the 3FM specification, which allows design applications to send full-fidelity 3D models to a mix of other applications, platforms, services and printers. The first version of the specification is available now for download at no charge!

We’re in great company as the other members of the 3MF Consortium are: Dassault Systemes S.A.; FIT AG/netfabb GmbH; Microsoft Corporation; HP; SLM Solutions Group AG; and Autodesk. For additional background, the 3MF Consortium is a Joint Development Foundation project. The Joint Development Foundation is an independent non-profit organization that provides the corporate and legal infrastructure to enable groups to establish and operate standards and source code development.


The mission is to deliver a 3D printing file format that is:

  • Rich enough to fully describe a model, retaining internal information, color, and other details.
  • Extensible so that it supports new innovations in 3D printing.
  • Practical, simple to understand and easy to implement.
  • Free of the issues inherent in other widely used file formats.


While modern 3D printers, including lower-cost models, are capable of printing items that are otherwise difficult to describe using existing formats it was definitely time for a change. The 3MF specification eliminates the problems associated with currently available file formats, like STL (which was originally designed in 1989!). It resolves interoperability and functionality issues, and will allow for further innovation in the industry.

Sounds great, right?

So how did this all start? It all began with a discussion among industry leaders regarding the best way to enable all of our various products to work well together. The group determined that the best approach would be to create a new 3D file format and support it through a collaborative effort with broad industry involvement. Accordingly, Microsoft donated its 3D file format work-in-progress as the starting point for the 3MF Consortium’s further development of the specification.

We’re honored to be a part of this amazing group and hope the 3D printing community is excited for what’s to come. We’ll be sure to keep the community updated as things progress and new versions of this specification are released!

3DPrintingDog Creates 3D Printed Kinetic sculptures

Some of the best designs we come across on Shapeways are the ones that take advantage of the printers we use to create incredible unique products we’ve never seen before. A Digital design studio called 3DPrintingDog based out of Philadelphia, PA uses the power of Shapeways SLS (Selective Laser Sintering) printing to make 3D printed Kinetic sculptures that come out of the printer with no assembly required. Here are a few examples of the designs that they’re making designed with Solidworks.

Deconstructed Bicycle Freewheel


Deconstructed Bicycle Freewheel

What are some of your favorite fully articulated designs you’ve come across on Shapeways? Let us know in a comment below or tweet us @Shapeways.

Two New Visualizations in Shapeways 3D tools: Bounding Box and Parts

Designing for 3D printing is more than just making a 3D model.  It’s understanding how big you want your figurine to stand on your desk, how thin your ring can be in plastic versus gold, and keeping track of all the details on intricate models while making sure all the parts are connected.  We launched Shapeways 3D tools in January to help bridge the gap between creating and designing a 3D model and actually  having it printed by giving you more confidence to know when your model is ready for the printers.

Today we are launching two new visualizations in 3D tools to help you further understand what your model will look like when it lands in your hands: a bounding box visualization and a part count visualization.

 Understanding Model Size: Material Specific Bounding Box Visualization

Understanding how big or small your model is physically and what materials you can print it in based on it’s size can be challenging when you are staring at your model on a screen and can easily zoom in and out.  This is especially true if you are designing for multiple materials – what’s the right size model that lets you print in all your favorites? Understanding how to change your model to make it the right size – is one part of the model too long? Do I just need to scale it slightly smaller? – can be tricky without being able to see the maximum and minimum size you can print in for a specific material.

By clicking on the bounding box tool in 3D tools, you can understand both how large or small your model is in relation to the bounding box for a specific material, and what part of your model is too big or small. Our visualization combines two elements: coloring parts of the model that are too big or too small red so you know which parts have issues, and visualizing the maximum and minimum bounding box oriented around your model as a transparent box.

When your model is within the size guidelines to be printed, you will see it inside the maximum bounding box.  So if you were thinking of making it a bit bigger or smaller, you can get a sense for how much you could change the size of your model.

size, bounding box, visualization, shapeways

If your model is too large, the part of the bounding box where the model is sticking outside the maximum bounding box will turn red to help you identify along which dimensions your model is too large.  If you have a multiple part model, only the parts of the model that exceed the bounding box size restrictions will turn red. Parts of your multiple part model that are OK in size will remain grey.

bounding box, size, too big, shapeways, visualization

If your model is too small, you will see it colored red inside a minimum bounding box.  By moving your model around, you can see which dimension(s) of your model are too small.

bounding box, size, too small, visualization, Shapeways

Identify Accidental Loose Shells: Part Count Visualization

Building detailed, complex models can result in incredible creations that are a marvel to hold and see.  Sometimes though, with so many details and parts, loose shells can accidentally be created.  Loose shells are pieces of your model that are separate and unconnected from the base part of the model. These can be intentional, but are often unintentional.

Our new part count visualization helps protect you from ordering a model you expect to come in one piece, but actually receive in many pieces because it uniquely colors each and every part. For example, in this model made of connected stars, all the stars were intended to connect to each other except two of them were slightly misaligned.  With the part count visualization, you can clearly see the accidental loose shells – the two unconnected stars – and fix your model appropriately.

part, multiple parts, part count, 3D tools, Shapeways

Go to 3D tools today from My Models or Model Edit and check out your models in the bounding box and part count tool to see how big or small your models are or if you have any accidental loose shells!