Instant Slic3r: Unravel the mysteries behind taking a virtual model and turning it into a physical object

Slic3r is undergoing lots of development. This recipe will talk about how to get the latest stable release. While you can get the latest release if you build from the source, we're going to talk about getting the release built here, in this recipe, because it will be the most stable. If you are interested in building from the source, we will cover that at the end of this recipe.

As we talked about earlier, we are getting the release version.

Once you have the software downloaded, it's time to put it where we want it. There's no actual installation, as it is a standalone program.

Now you can launch Slic3r as you would any other program on your OS.

Slic3r is built on the Perl programming language with some parts written in C++. Perl is known for its ability to parse files in a quick and efficient manner, and is one of the reasons why Slic3r is so fast at slicing STL and other files.

It is also a language that is known for allowing developers to work quickly, though it is also notoriously hard to read for people not familiar with the language.

Slic3r is undergoing constant development. At the time of writing, there have been incremental versions every two to three months. The primary developer of Slic3r, Alessandro Ranellucci, is constantly making improvements in speed and adding new features. He is assisted by several other developers and the open source community, comprising of you and me.

The first thing we need to make sure is that the printer, which we will be calibrating, is set up properly and will be able to produce a good print on its own. What this means is that we need to make sure of the following:

The bottom line for this is to make sure our printer itself is calibrated and functional before adding something else to calibrate. If the printer isn't calibrated correctly, we will have a hard or impossible time calibrating Slic3r to produce good prints.

While it is possible to configure Slic3r using the command line, the developers of Slic3r have made things easier for us—the new and experienced 3D printer owners. They've produced a Configuration Wizard to help get Slic3r set up and ready for printing our first print easily.

Let us see what steps we need to follow for setting the physical printer properties:

Slic3r needs these steps done in order to produce good prints. Letting Slic3r know our printer's specifications means that when it slices models for printing, they will be in a scale that matches our printer.

Making sure our printer is solid, with no wobbling or shaking, will let our printer not mar or destroy the object we are trying to print. If we don't have these things set correctly, the print could be misshapen, the print nozzle could hit the print bed, or worse.

Low cost, home 3D printing is a new field. Don't be discouraged if our first few prints aren't perfect. Here we will look at some good sample models to do test prints with, saving multiple configurations to help us try and dial in the quality of our printer.

Testing the settings and printing our first model

The Slic3r interface

So we've calibrated our printer hardware and have run through the Configuration Wizard. Now, we print! Okay, not yet, we don't have a model to print.

Getting a model isn't hard at all. People have been making models for 3D printers like ours for a while now. One good site is Thingiverse (http://www.thingiverse.com). While any model there could be printed, for our first print, we would want to start off small.

Why small? We don't want to waste plastic, and more importantly, time, on a print that might not come out right. There are two models I suggest: Snake by Zomboe (http://www.thingiverse.com/thing:4743), and Torture Test by MAKE (http://www.thingiverse.com/thing:33902). Both are smaller and they test our printer's capabilities.

If we are setting up this printer for the first time along with setting up Slic3r, another good model would be the 20mm Cube by Engineglue (http://www.thingiverse.com/thing:34553). By printing this, and stopping the print before it has started printing the top, will allow us to measure its wall thickness, see how true our x and y axis are, and even calibrate our flow rate.

Slic3r can use several different file types. The ones at Thingiverse are almost always the first and most accepted 3D printing format: STL. It stands for StereoLithography, which is another form of 3D printing that is becoming more available to hobbyist 3D printers.

The other two formats are Wavefront OBJ, and Additive Manufacturing File Format (AMF). AMF is actually now a standard for 3D printing, because it can do things STL files can't, such as describing colors and materials in the modeling file. It's newer and still hasn't caught on as much as the de facto standard of STL files.

Now that we've got a model, either from a third party, or the one that we have build ourselves, we can set up our first print.

In the Slic3r GUI, the first tab is called Plater. Plater allows us to load and place objects to be printed. There are a couple of nice things about Plater. One, we can just drag-and-drop objects into it from our desktop. Two, we can load in more than one object to print and arrange them on the print area so we don't have to have multiple prints for a bunch of smaller objects.

So let's go ahead and drag a model in, or use the Add... button on the same tab window. Once it's loaded, several other option buttons will become enabled. We are going to leave those alone for now, as we just want to print the model.

Now, we print!

Go ahead and hit Export G-code... to slice our model and use your printer software to print the object. If you are using printer software that has Slic3r built in, print using its instructions.

In the Calibrating Slic3r to your printer (Must know) recipe, we went over how to set up Slic3r and testing a print. Now we want to update Slic3r, or change to a different printing software, but still use Slic3r for slicing our models to print.

Most printing software that comes with Slic3r will release an update just after Slic3r releases a new build. So the easiest way to update is to just wait for one.

What if we want a feature now though? What if we've edited the Slic3r code ourselves and want to test it before submitting a pull request to the Slic3r repository? The process for installing a new version of Slic3r in most printer software is quick, once you know how.

The instructions here are based on the Windows version of Slic3r. Most, however, can be be used with Mac and Linux installs with little or no changes.

For those of us with the Printrun suite of software, we'll the next set of instructions to install or upgrade Slic3r.

Printrun is actually a collection of software: Pronterface, Prontserve, Pronsole, and Printcore. Pronterface is the actual printing software that we need to integrate Slic3r with.

For more information on Printrun, including more details on how Slic3r can be integrated into Printrun's settings, head over to the Printrun repository at https://github.com/kliment/Printrun.

Another popular printing software is Repetier-Host. Repetier-Host comes with Slic3r, so updating it is quite easy.

Replicator-G is what comes with MakerBot, so its popularity has been tied to the popularity of the MakerBot itself.

Replicator-G comes with Skeinforge installed by default, so we need to make some changes to get it to use Slic3r. It isn't as easy to switch as Repetier-Host is, but it's only a little more difficult than Printrun. So if you aren't comfortable with overwriting the previous version of Slic3r, skip to the There's more... section for another way to use different versions of Slic3r with Replicator-G.

This will change out Slic3r for Replicator-G. The settings for Replicator-G are still experimental, so some tweaking will be needed to get really good prints.

To use Slic3r with Replicator-G, navigate to GCode | GCode Generator | Slic3r 0.X - Experimental.

We all have our own favorite things we use. Printing software is no different. We've decided to either give Slic3r a try on our favorite software, or try out different printer software. Either way, we need to know how to get the software to talk to each other.

Just like an inkjet or laser printer, a 3D printer has to get a file from the computer in a certain format in order to print. This is usually handled by printer drivers for that particular printer.

Personal 3D printing isn't quite to that stage yet, so we need to provide the printer with input that it can understand. You can think of Slic3r as part of the Print Settings dialog that would normally come up before printing on a paper printer. The printer software is a combination of the printer driver and the rest of the options in the Print Settings window.

Not every 3D printing software will take Slic3r as its slicing software. There are still a few ways we can use Slic3r on our favorite printer software.

Open up Slic3r and go to the Print Settings tab. We're staying in the Simple mode for now, because it's easier to track the changes we make to the changes in our final print.

The Print Settings section is where a lot of changes will happen as we print. Let's go down the list of options in this section so we know what they are and why we might want to change them, sometimes from print to print.

Layer height, infill settings, perimeters, what does it all mean? Let's look into those settings and what they stand for, in more detail.

Settings can be more than just settings. More than just a tool for making nicer quality prints. We can use some settings to alter the objects themselves, to make changes to the objects, and have it come out as what we want without having to touch the modeling software.

Sometimes the prints don't come out well as we would like them. This recipe will help us refine the objects that we print. So let's pull out our favorite torture test model file and let's get to work.

We'll now go through the steps to give us access to the more advanced settings. With access to these, we will be able to make better prints, faster, and more reliably than just using the basic settings we have been using.

Now that we know how to change the settings here and little of what they do, let's go over things in a bit more detail. First, let's look at the changes we made in the Print Settings tab.

By digging deeper into Slic3r's settings, we will find a variety of settings that we haven't touched on yet. Some we may never use, but some may be important to our specific printer. Here are two examples.

Remember those models we used to test our printer capabilities earlier? Well, dig out those files again, because we're going to use them to help troubleshoot our printer problems. If you've gotten rid of those early files, here they are again:

The following section contains several troubleshooting methods to help with various issues with printing. It will help us go through our Slic3r settings to alleviate or even remove the problems.

One very common problem people have with their printer is the print not sticking to the print bed. There are several possible reasons for this:

Troubleshooting is a skill in itself. Many people believe they are troubleshooting, when really they are causing more problems for themselves by fiddling and changing things, but not paying close attention to what they are actually doing. If it works for them, they are satisfied.

Unfortunately, those people are missing half of what troubleshooting is about—learning more about the thing they are working on.

We've talked before about changing one setting at a time in this book. There's a reason for that. Proceeding in a manner that is known will lead us to learn what is actually wrong with our printing, and also show us what changing our settings actually does to our prints.

So many people change settings, fiddle, and look up information that they don't take the time, or don't know how, to troubleshoot. We know the problem, what we are trying to do is find the cause. We can't find the cause if we don't approach our troubleshooting with a plan in mind.

These steps are very simple, but essential for us to remember when trying to solve issues with our printing. Taking small steps and noting the changes will help us understand our printer's capabilities better, and help us diagnose problems more quickly in the future.

3D printing for us is very new. There are so many things that can go wrong. When something does, try to isolate the issue. Make one change at a time and see how it affects the print. Changing multiple things at the same time to fix an issue won't tell us what worked and what did not, or even what made it worse.

It will take longer to solve with this method. When we run into the same issue again in future, and we will, we will remember our earlier issue and have a good place to start when troubleshooting the new one.

So now that we know about the command line, how do we get to it?

We'll now see the list of Slic3r commands that are available to us. If you'd like to look at the list, they are listed in the How it works... section of this recipe.

Because Slic3r command line options are normally built in one line, we'll be splitting out the options into separate steps. At the end, we'll put it all together to run.

Slic3r will take the file, scale it up 200 percent as it slices it, and then output our file to modelFilename.gcode.

So now that we've looked at some things we can do with the command-line options, the ideas for what else we can do are starting to come to mind. The command-line options can be called from the programs we write, or set up to run later using the scheduling in Windows or cron on Linux and Mac. We can also set up web pages or mobile apps to call Slic3r.

The following is a list of what we see when we list out the help for Slic3r. There are wealth of options available to us. Look through it, and ideas for how to use Slic3r from the command line will continue to flow:

Slic3r 0.9.10b is a STL-to-GCODE translator for RepRap 3D printers written by Alessandro Ranellucci <aar@cpan.org> - http://slic3r.org/
Usage: slic3r.pl [ OPTIONS ] file.stl

This first section of the help is the general options, allowing us to check the version, to load and save configuration files, and even specify the number of processor threads that Slic3r can use. The following table lists them out:

The output options are exactly what it says, the different settings we can use for output. This includes post processing, svg export, and merging multiple files into a single print.

Here is where we can tell Slic3r about our printer: the physical sizes, and what type of G-code that Slic3r should expect.

Filament options gives us finer control over how Slic3r will handle our plastic that we are printing with. We can change the first layer's temperature compared to the later layers, what the bed temperature should be, and what diameter filament we are using.

Speed options is where we can make our prints run faster, but if we aren't careful we will sacrifice quality. Some areas, such as gap filling, we may want to run faster, so there is less chance of sagging.

Depending on the physical stability of our printer, adding in acceleration with these options can help speed up and improve the quality of our print.

Accuracy options is a little misleading. While adjusting layer height does usually yield smoother prints, adding in infill can also make the print sturdier.

Print options is also confusing at first, because it sounds like a catch-all category. These are the actual settings for the object to be printed: if it should have a solid top or bottom, how dense the fill material will be, and also allow us to use custom G-code for the start and end of the print.

When we use support material, the following are the settings we would want to adjust. These tell Slic3r to use a support material or not, and where.

Since the extruder is making the plastic filament more liquid, we will sometimes need the extruder to run backward, pulling the plastic back in so we don't get blobbing and dripping.

If we are using multiple extruders, we definitely want to retract the plastic of the extruder that just finished so that it doesn't drip or dribble over the new plastic from the other extruder.

Having the print sag, pop off the build platform and having gaps between layers can all be related to improper cooling. Slic3r gives us good controls over the cooling of the print with the following settings:

If we need to pre-extrude some plastic before printing the object, or have Slic3r add a brim to help the model stick to the platform, the following are the settings we will use.

We can change the size and position of the object we want to print, without going back to edit the model. Using the two duplicate settings, we can even print several copies of the same object at the same time.

Sometimes we want to finish a whole object in a print file before moving on to the next one in the file. We need to be careful about where the extruder head goes so that it doesn't hit any of the objects. Also, having one of the parts done while the others print can sometimes be just what we need.

If we want to add in some comments to the output file, such as the date it was printed, what printer settings were used, even notes to ourselves on why we used the settings we did, we can put those in using the following option:

The following are fairly advanced options, dealing with how wide the Slic3r will make the extrusion layer, if it should have a different first layer, and even have a different width between the perimeter and infill:

Previously, we had some multi-extruder options with the retraction settings. These settings round out the other settings that we need to use with more than one extruder.

There are many things that we can do with access to the command line. Every system that it runs on is capable of running a timed process, or a batch process.

So let's think about a few things we could do by using the command line. We could make a process that accepts models from the Web and automatically slices them and start a print remotely. We could even set up a webcam to watch the print in progress.

Taking that one step further, we could have other people upload their models. A Slic3r script could then calculate the amount of plastic needed and charge them for the print. They could watch the print on the webcam and see the results even before we put it in the mail to deliver.

That's just one idea of what we could do with access to the command line. Just like having your own 3D printer at your disposal, the sky is the limit for what we can do with Slic3r.

For this recipe, let's slice up one of our torture test files to look at. Let's take Snake by Zomboe (http://www.thingiverse.com/thing:4743) to look at.

We will slice the file and take a look at the generated G-code that Slic3r produces.

Now that we have our model sliced, let's take a look at it:

; generated by Slic3r 0.9.10b on 2013-08-07 at 08:28:44

; layer_height = 0.4
; perimeters = 3
; top_solid_layers = 3
; bottom_solid_layers = 3
; fill_density = 0.4
; perimeter_speed = 30
; infill_speed = 60
; travel_speed = 130
; nozzle_diameter = 0.5
; filament_diameter = 3
; extrusion_multiplier = 1
; perimeters extrusion width = 0.53mm
; infill extrusion width = 0.53mm
; solid infill extrusion width = 0.53mm
; top infill extrusion width = 0.53mm
; first layer extrusion width = 0.70mm

G21 ; set units to millimeters
M107 ; disable fan
M104 S200 ; set temperature
G28 ; home all axes
G1 Z5 F5000 ; lift nozzle

M109 S200 ; wait for temperature to be reached
G90 ; use absolute coordinates
G92 E0 ; reset extrusion distance
M82 ; use absolute distances for extrusion
G1 F1800.000 E-1.00000 ; retract
G92 E0 ; reset extrusion distance
G1 Z0.350 F7800.000 ; move to next layer (0)
G1 X55.204 Y56.037 ; move to first skirt point
G1 F1800.000 E1.00000 ; compensate retraction
G1 X56.044 Y55.197 F540.000 E1.03865 ; skirt
G1 X57.054 Y54.367 E1.08118 ; skirt
G1 X58.204 Y53.757 E1.12354 ; skirt
.
. <truncated for brevity>
.
G1 X114.772 Y113.057 F600.000 E1.01138 ; perimeter
G1 F1800.000 E0.01138 ; retract
G92 E0 ; reset extrusion distance
M107 ; disable fan
M104 S0 ; turn off temperature
G28 X0  ; home X axis
M84     ; disable motors

; filament used = 681.3mm (4.8cm3)

; avoid_crossing_perimeters = 0
; bed_size = 200,200
; bed_temperature = 0
.
. <truncated for brevity>
.
; wipe = 0
; z_offset = 0

The actual file is much longer than the one we have here, but this gives us a good section to look at. So what are we seeing here?

The first part, each line starting with a semi-colon (;) are comments. They tell us when the file was slice, and helpfully, what are the settings for. So if we have a file that we feel prints perfectly, but don't know what configuration we used, we can go back to the sliced file and get the settings again.

In G-code, the semi-colon (;) stands for a comment. Comments can be on a line by themselves or as part of a line:

; first layer extrusion width = 0.70mm
M104 S0 ; turn off temperature

Once a comment is started though, it continues to the end of the line. This may be useful if we want to save a sliced file and add in notes of our own. We can also use post-processing scripts to add in G-code, and comments about what it does.

After the comments is a long set of lines with letters and numbers. The letters indicate the type of action that is to be performed, and the numbers indicate either the action itself, or the interval that is used in the action.

More information on 3D printing G-code can be found at the RepRap wiki (http://reprap.org/wiki/G-code). Though not all firmware support all of the G-codes listed there.

The following list contains the most common letters in our G-code file. They are listed in order of importance and frequency:

Slic3r also allows us to input extra G-code at the time of slicing. We can have it input code at the start of a print, the end of a print, each time a print layer is finished, and whenever a tool is changed (in our case, this means switching to a different extruder).

These can be set in the Printer Settings tab under the Custom G-code selection. We see that Slic3r already puts in some G-code for us for the common printing tasks.

For this example, we will use one of the scripts put together by the developers of Slic3r to compute the cost of the filament used. The example script is in Euros, and the cost is just an example. To get the cost, we will need to change the units later, calculate the cost of the filament we are actually using, and put it into the script. For now though, we will go with the default script.

A good idea is to keep all of our scripts in one place. A scripts folder inside the Slic3r folder is a good place, or you can place it in our user directory. When updating Slic3r, make sure that we back up the folder before installing the new version.

Each script must be executable by the host system, and must be a script that the host system can run. As noted previously, Perl isn't on Windows by default, so it would need to be installed. However, other scripting languages could be used by Slic3r.

Post processing scripts are passed the full path to the sliced file. Slic3r configuration options are available to post-processing scripts as environment variables that start with SLIC3R_.

Because post-processing scripts are able to call anything they normally could, it is even possible to make calls to a server and pass along data for the server to store or do other things with.

As mentioned in the previous section, the scripts don't have to be all in Perl. It just happens to be the language that the developers prefer, and that Slic3r itself is written in.

For Linux and Mac users, we can use shell scripts to call other programs, or do processing itself.

For Windows users, the basic batch file can be called.

If we need arguments passed to the script, Slic3r cannot do that. We would need to create another script for Slic3r that wraps our original script. That script would then call our original script with the arguments we want.