A GPU accelerated modeler and slicer


New version available! Runs on all GL4.3 GPUs, supports Replicator and Ultimaker printers (and others), tons of new features!

Some functionalities are unstable on AMD and Intel hardware. We are working on improving the compatibility.

IceSL is a modeler and slicer, all in the same software. Think of it as OpenSCAD meets Skeinforge. By directly slicing the models IceSL avoids the expensive mesh CSG computation that most other softwares have to perform. In addition, IceSL relies on recent GPU algorithms to speed up visualization as well as the slicing process. On-screen preview is accurate and slicing is fast.

Beware that we have high GPU requirements, and that IceSL is experimental software. Currently, IceSL is only available for Windows.

Joint us on the IceSL Google group for more discussion!

Change log (latest)

  • Brushes! Select different print parameters in different objects.
  • Transparent rendering is back (unselect 'Opaque' in the interface)
  • Basic supports (see manual). Our support technology is not yet ready for release, so in the meantime we implemented a basic support approach.
  • Linear offsets, for carving the inside of your objects or making molds.
  • Fixed bug preventing running on ATI cards on previous release ...
  • Settings are now saved independently for each printer.

Quick start

  • Download and unzip.
  • Create 'helloworld.lua' in 'icesl/bin'
  • Open it with your favorite editor (we use Notepad++).
  • Write 'emit( box(10) )', save.
  • Drag and drop the file onto IceSL.exe (or launch from command line with 'IceSL helloworld.lua').
  • IceSL opens and you can see a cube. IceSL tracks changes in 'helloworld.lua'. If you modify and save, it will immediately update the view.
  • Click the 'slice' button. G-Code is produced in 'helloworld.gcode'.
  • Open the G-Code in your printer host software, print. For instance, on a Makerbot Replicator 1 Dual + Sailfish use ReplicatorG to save G-Code as an S3G/X3G file on the SDcard.
  • Read the warning! ... print.


IceSL uses Lua as modeling language. For instance: thumbnail s = sphere(10) emit(s) creates a sphere of radius 10 mm (millimeters). Note the emit function to spawn the primitive into the scene. In particular: thumbnail s = sphere(10) b = box(15) emit(b) creates the box in the final scene but not the sphere.

IceSL supports difference, union and intersection: thumbnail s = sphere(10) b = box(15) emit( difference(b,s) )

There are many, many other features, so be sure to read the documentation for all possible instructions.


  • Lua-based modeling language.
  • Shapes as Lua variables.
  • Nested slices for faster printouts!
  • Loads STL, OBJ, 3DS.
  • Basic primitives (sphere, cylinder, cone, box).
  • CSG operations (union, difference, intersection).
  • Interactive on-screen editing: move, resize, cut, assemble.
  • 3D transforms (matrices) and points as Lua variables.
  • Linear surface offsets on meshes.
  • Multiple printing heads (use of different colors, materials).
  • Slice shaders!
  • GPU-based slicer, with all basic options (shells, infill, cool, etc.)
  • Comes with many examples and powerful scripts: spider robot, android model, articulated dog miniature, libraries for gears, pins, etc.


image post
Dragon by Valentine Left: erosion, Middle: original, Right: dilation.

Linear offsets can be combined to erode or dilate an object, making a thinner or thicker version of it. Our technique is both precise and efficient.

Nested slices

Nested slices let you use thick slices inside the object while using fine slices for the outer shell of the object. For instance if you select a layer thickness of 0.1 mm and 3 nested slices, the inner slices will be 0.3 mm thick. Print faster with no compromise on quality!

Slice shaders

Each time IceSL processes a slice, it runs slice shaders on its surface. The slice shaders let you change the geometry and material along the slice. There are two types of slice shaders: Material and warp. The shaders are functions written in GLSL.

  • A material shader can change the toolhead used in any point of the slice, or simply decide to carve a hole.
  • A warp shader can deform the slice (only in the XY plane).

Visualization in the main window is however limited to tool change. To visualize warps or carving, the G-Code has to be produced first (IceSL displays G-code after generation).

Dual color print of thing 16378. Preview in IceSL (left) and printed model (right). The black and white stripes are produced by a material shader. The stl is the unmodified thing 16378. See the Lua script and the material shader.

Supported printers

IceSL produces G-Code through customizable printer profiles (please see the documentation). We provide several printer profiles directly selectable from the interface. We use IceSL on a regular basis on a Replicator1, Ultimaker1, Ultimaker2. We successfully tested IceSL on a Replicator2 and a FoldaRap.

Given a script 'thing.lua' as input, IceSL will generate G-code in a file named 'thing.gcode'. To send the code to the printer use your favorite host software. We use ReplicatorG with Sailfish firmware on our Replicator Dual. When targeting an Ultimaker (1/2), the G-Code can directly be used on the printer.

If you are manufacturing printers and would like us to create a profile for your printer, we welcome hardware donations ;-)

Please be extra careful if you modify the profiles. The G-Code could make the nozzle collide with the platform or worse. Closely monitor the prints.

image post

GPU requirements

IceSL is a prototype software using advanced GPU capabilities. It requires a GPU with full OpenGL 4.3 support. It has been tested on the following hardware:

  • [tested] GeForce GTX 480 / 580 / 680 / Titan
  • [tested] GeForce GT 555M
  • [tested] Intel HD 4400
  • [tested] AMD Radeon 290X
Please make sure to install the latest drivers.


IceSL is highly experimental software. You may harm your printer by using the G-Code it generates. We strongly recommend that you visually check the produced G-code (for instance we use Repetier-Host), and that you supervise the start of the printing process to avoid any damage to the printing nozzle due to improper z-levels or default positioning of the printing mechanism. We typically keep a finger on the switch at the start of the prints.


IceSL is free for non-commercial use (contact us for all other cases). The full licence text is here.

Please acknowledge us in any publication (paper, web page, blog, etc.) showing results done with IceSL: This is important for us to get support and continue our work.


  • Can I output a STL? No, not directly. IceSL is meant to generate G-Code. If you really need a mesh then you can always export a 'csg' file that can be processed by OpenSCAD.
  • Will you support other GPUs? We hope that will be the case soon -- it essentially depends on the availability of specific hardware features, and whether we find time to develop a different code path.
  • Could the produced G-Code break my printer? Bad things could happen, yes. So be careful, check the G-Code, do not leave the print unattended. We never broke our printer, but we are extra careful.
  • IceSL is freezing when slicing... This is expected. During slicing the main window freezes and the output only occurs in the console window. If you are slicing a complex object this may take some time. Check out the progress bar in the console; it gives an approximate time until completion.
  • Text editor? IceSL will not include a text editor. It is designed to monitor file changes to the Lua script file and update the view whenever the script changes. This lets you use your favorite editor. For instance we use Notepad++ which features syntax highlight for Lua.

Contact Info

Phone: +33 3 54 95 86 53

E-mail: Sylvain Lefebvre at inria dot fr