Is There a Trick to Remove 3D Printing Supports?

There is no one “trick” to removing supports generated by PrusaSlicer, but there are some general strategies that can make the process easier and more effective. Here are a few tips:

  • Orient your model carefully: When designing your model, try to orient it so that overhangs and other areas that require support are facing downward. This can reduce the amount of support material needed and make it easier to remove.
  • Adjust support settings: PrusaSlicer offers many settings that can affect the quality and amount of support material generated. Consider adjusting settings such as support density, contact point size, and support angle to find the optimal settings for your particular model.
  • Use support blockers: PrusaSlicer also allows you to use support blockers to prevent support material from being generated in specific areas. Consider using these blockers strategically to reduce the amount of support material generated.
  • Use the right tools: When removing supports, use tools that are appropriate for the job. For example, small pliers or tweezers can be helpful for removing small support structures, while a sharp knife or flush cutters can be useful for larger structures.
  • Be patient: Removing supports can be a tedious and time-consuming process. Take your time and work carefully to avoid damaging your model.
  • Adjust support interface settings: Support interfaces are the layers of support material that come into contact with your model. Adjusting settings such as interface density, interface layer count, and interface pattern can help create a smoother surface on your model where support material was attached, making it easier to remove.
  • Use support enforcers: Similar to support blockers, support enforcers can be used to ensure support material is generated in specific areas. This can be helpful when you need additional support in certain areas, but want to reduce the amount of support material generated overall.
  • Use a heat gun: If your model is printed in PLA, a heat gun can be used to soften the support material, making it easier to remove. Be careful not to overheat the material or your model, as this can cause warping or other damage.
  • Experiment with different support materials: PrusaSlicer allows you to choose different types of support material, such as water-soluble support material. Experimenting with different materials can help you find the best solution for your specific model.
  • Use support release agents: Applying a release agent, such as cooking spray or isopropyl alcohol, can help loosen support material from your model. Be sure to test this method on a small area of your model first to ensure it does not cause any damage.

By using these additional tips, you should be able to improve your experience with removing supports generated by PrusaSlicer.

PETG “Blobbing”: What is it, and how do I prevent it from happening?

PETG Blobbing

PETG is a popular material for 3D printing because of its transparency, flexibility, and ease of use. However, one common problem that many 3D printing enthusiasts face while using PETG is a phenomenon known as “blobbing”. Blobbing occurs when the melted filament leaks out of the nozzle and forms small droplets of plastic on the surface of the print. This not only affects the appearance of the final product but can also cause printing issues such as layer separation or poor adhesion. In this article, we will discuss some of the key ways to avoid PETG blobbing and achieve a smooth and successful 3D printing experience.

Clean the Nozzle Regularly

One of the most common causes of blobbing is a clogged nozzle. A clogged nozzle prevents the filament from flowing smoothly and can lead to leakage and blobbing. To avoid this issue, make sure to clean your nozzle regularly and check for any blockages. You can clean the nozzle using a nozzle cleaner or by carefully heating up the nozzle and wiping it with a clean cloth.

Control the Flow Rate

The flow rate, also known as the extrusion multiplier, determines how much filament is extruded per step. If the flow rate is set too high, the filament can be extruded too quickly and cause blobbing. To avoid this, you can adjust the flow rate in your slicer software and experiment with different settings to find the optimal value for your printer.

Keep the Bed Temperature Low

The bed temperature plays a crucial role in preventing blobbing. If the bed temperature is too high, the melted filament can stick to the bed and cause blobbing. To avoid this, it is recommended to keep the bed temperature low, especially for the first few layers. The ideal bed temperature for PETG is between 70-80°C.

Use the Correct Retraction Settings

Retraction is the process of pulling the filament back into the nozzle to prevent oozing when moving between different parts of the print. If the retraction settings are incorrect, the filament can leak out of the nozzle and cause blobbing. To avoid this, make sure to use the correct retraction settings for your printer and material, and adjust them if necessary.

Use the Right Nozzle Size

The size of the nozzle also plays a role in preventing blobbing. A smaller nozzle size can cause filament to clog and blob, while a larger nozzle size can cause filament to leak out. To avoid this, make sure to use the right nozzle size for your material and printer.

Blobbing is a common issue when 3D printing with PETG but can be easily avoided by following these simple steps. By keeping the nozzle clean, controlling the flow rate, keeping the bed temperature low, using the correct retraction settings, and using the right nozzle size, you can achieve a successful and smooth 3D printing experience with PETG.

3D Printing: A Beginner’s Guide

3D printing is a form of additive manufacturing that allows for the creation of three-dimensional objects from digital designs. The process involves the use of a 3D printer, which is a machine that builds objects layer by layer until the final product is complete. This technology has been around for several decades and has revolutionized the way we create and manufacture objects.

How Does 3D Printing Work?

The process of 3D printing starts with creating a digital design using computer-aided design (CAD) software. The design is then sliced into thin layers and sent to the 3D printer. The printer then starts building the object layer by layer, using materials such as plastic, metal, or ceramic. The printer applies the material in a controlled manner, fusing it together to form the final product.

Types of 3D Printing

There are several different types of 3D printing technologies available, each with its own unique advantages and disadvantages. Some of the most common types of 3D printing include:

  • Fused Deposition Modeling (FDM): This is the most common type of 3D printing and uses a thermoplastic material that is melted and extruded layer by layer to form the final product.
  • Stereolithography (SLA): This type of 3D printing uses a laser to cure a photopolymer resin layer by layer. The process is precise and creates highly detailed objects.
  • Selective Laser Sintering (SLS): This type of 3D printing uses a laser to fuse powdered materials together to form the final product. It is a popular choice for producing functional prototypes and end-use products.
  • PolyJet Printing: This type of 3D printing uses a process similar to an inkjet printer to build objects. The printer jets a photopolymer material layer by layer to form the final product.

Benefits of 3D Printing

3D printing has several benefits over traditional manufacturing methods, including:

  • Speed: 3D printing can significantly reduce the time it takes to create a prototype or finished product.
  • Cost: 3D printing can save money compared to traditional manufacturing methods, especially for small production runs or unique designs.
  • Customization: 3D printing allows for the creation of highly customized and unique objects that may not be possible with traditional manufacturing methods.
  • Versatility: 3D printing can be used to create a wide range of objects, from toys and jewelry to aerospace components and medical implants.

Getting Started in 3D Printing

3D printing is a rapidly growing technology that is transforming the way we create and produce physical objects. From prototyping to manufacturing, 3D printing has numerous applications across various industries, making it an exciting field to get into. Whether you’re a hobbyist, a designer, or an engineer, getting started in 3D printing can seem daunting at first, but with a little bit of guidance, it can be a fun and rewarding experience.

Here are some steps to help you get started in 3D printing:

  1. Choose a 3D printer: There are many different types of 3D printers available, each with its own strengths and weaknesses. Some popular options include Fused Deposition Modeling (FDM), Stereolithography (SLA), and Selective Laser Sintering (SLS). Consider factors such as cost, build volume, material options, and ease of use when choosing a printer.
  2. Learn the basics: Before diving into 3D printing, it’s important to understand the basics of how a 3D printer works and the various factors that can impact the quality of your prints. This includes things like layer height, infill, and nozzle size. You can start by reading online guides or watching instructional videos.
  3. Get the right software: To design your own 3D models or to prepare files for printing, you’ll need to use 3D modeling software. There are many different options available, ranging from free, open-source programs like Tinkercad and Fusion 360 to more advanced paid options like Solidworks and AutoCAD. Choose the software that best fits your needs and skill level.
  4. Start with simple projects: Once you have your printer and software set up, start with simple projects to get a feel for the process and to improve your skills. This could be anything from small keychains to more complex objects like phone cases or chess pieces.
  5. Experiment with different materials: 3D printing offers a wide range of material options, from standard filaments like ABS and PLA to more specialized materials like metal and wood composites. Experimenting with different materials can help you understand the unique properties and limitations of each one.
  6. Join a community: 3D printing is a vibrant community with a wealth of resources and support. Joining online forums, attending local meetups, or joining a 3D printing group can help you connect with other enthusiasts and learn from their experiences.

3D printing can be a fun and rewarding experience that opens up a world of possibilities. With a little bit of research, the right equipment, and a willingness to experiment, you’ll be well on your way to creating your own 3D printed creations.


C#: Quickly Propagating Properties of an Object to the Parent Class

To quickly implement the propagation of all of the methods from an object owned by a class (called “theObj” below), to the owner, you can use the C# Interactive Window. Right-click your C# project, and choose “Initialize Interactive with Project”. Then, create an instance of your object, and extract the methods in the interactive window using the code below. Copy and paste the methods into your class’s code, and then manually edit any problematic results (i.e. generics won’t appear properly).

You can repeat this process for properties and events, simply changing the code to suit your needs.

theObj = new TheObjectTypeIWantToExpose();
var props = theObj.GetType().GetMethods(System.Reflection.BindingFlags.DeclaredOnly | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.Instance);

foreach (var prop in props) {
    if (prop.Name.StartsWith("get_") || prop.Name.StartsWith("set_") ||
        prop.Name.StartsWith("add_") || prop.Name.StartsWith("remove_")) continue;

    var parameters = prop.GetParameters();
    List<string> paramlist = new List<string>();
    List<string> paramnames = new List<string>();
    foreach(var param in parameters)
        string curParam = param.ParameterType.FullName + " " + param.Name;

    string allParams = string.Join(",", paramlist);
    string allNames = string.Join(",", paramnames);

    Console.WriteLine($"{prop.ReturnType.FullName} {prop.Name}({allParams}) => TheChildObject.{prop.Name}({allNames});");

Fix for applications that do not support high DPI

I recently got a Microsoft Surface Pro, which has a high DPI display.  Many apps do not display properly, because they are not DPI-aware.  Here’s how to fix that in Windows 10/Windows Server 2016:

  1. If the program(s) you need to fix are in the Program Files folder(s), you’ll need Administrator rights.
  2. In your registry, tell Windows to prefer external program manifests over embedded ones:
    1. In RegEdit, go to the key:
    2. Add a new DWORD 32-bit value:
      and set it to 1.
  3. Create a text file in the same folder as the program with the exact same name as your the program including the .exe extension, and add a second extension, .manifest.  So, if your program is called Program.exe, you’ll create a new text file called Program.exe.manifest.
  4. Edit the text file, and add the following code to it:
    <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
    <assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0" xmlns:asmv3="urn:schemas-microsoft-com:asm.v3">
          version="" processorArchitecture="*"
    <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">
      <asmv3:windowsSettings xmlns="">
        <ms_windowsSettings:dpiAware xmlns:ms_windowsSettings="">false</ms_windowsSettings:dpiAware>

Note that if you right-click and select Properties in Windows 10, there’s also a compatibility mode tab which has a setting that lets you override the application’s scaling properties.  However, this doesn’t seem to work on an RDP connection.  The manifest method above does work in RDP.


A Development SMTP Server for Testing

I needed a development SMTP server that I could use for testing with Microsoft Outlook, which would save the e-mails in a folder so I could go back to them.  I was already aware of python -m smtpd -n -c DebuggingServer localhost:25, but this solution allows me to open the results in Outlook.

I use this with Cygwin on Windows.

import smtpd
import asyncore
import io
import uuid
import os

class FileSMTPServer(smtpd.SMTPServer):
    def process_message(self, peer, mailfrom, rcpttos, data):
        f_name = os.path.join('mailroot', str(uuid.uuid4()) + '.eml')
        with open(f_name, "w") as out_file:

if not os.path.isdir('mailroot'):
print("Development SMTP Server Listening on Port 25")
server = FileSMTPServer(('', 25), None)


Save it as, and run it with python  It’ll create a folder called mailroot which will store each e-mail with a unique ID.

Note that you’d need to run this with sudo on Linux, or change the port number (port 25 in this example) to one above 1024.

Debian Root Drive on an F2FS Filesystem

F2FS is a filesystem that was initially developed by Samsung for flash devices.  I’ve seen several benchmarks (e.g. xda-developers) that seemed to imply that F2FS was faster than EXT4 on flash devices, so I decided to try it, as my EXT4 USB was very slow.  Writing this on an F2FS Debian root on a USB flash drive right now, I can attest to the fact that it is much snappier than a similar installation using EXT4.

As of this writing, Grub2 doesn’t support booting to an F2FS partiton, so the trick to getting an F2FS root is to have an EXT4 partition for your /boot, which loads the drivers and chroots into your root.

I haven’t worked out all the kinks yet, but here is the basic outline:

  1. Partition your flash drive with 3 partitions:
    1. /dev/sdX1 as EXT4 – your boot partition
    2. /dev/sdX2 as F2FS – your root (/) partition
    3. /dev/sdX3 as your swap
  2. Debootstrap /dev/sdX2, chroot, and mount sdX1 under /boot
    1. More specifically, I mounted sdX1 under /mnt, and then bind-mounted the /mnt/boot subfolder to /boot (mount --bind /mnt/boot /boot).  You might not have to do this; I’d think it should work with just /boot, but I haven’t tested it.  I copied /vmlinuz and /initrd.img from the host to /mnt/, so Grub would be able to find them easily.
  3. In your chroot, make sure you have /dev bind-mounted from the host, and have mounted /proc, /sys, and /dev/pts
  4. apt-get all of the packages you need, configure the system, etc.
  5. Be sure you change the root password with passwd, or create a new user account with sudo privileges!  Otherwise, you won’t be able to log into your system (guilty as charged).
  6. Build the f2fs driver into your initramfs
    1. echo f2fs >> /etc/initramfs-tools/modules
    2. update-initramfs -u
  7. apt-get install grub2 (if you haven’t already), and then do a grub-install /dev/sdX
  8. Do an update-grub2
  9. Make sure you have updated your /etc/fstab to mount the proper drives.  I like to use blkid to get the UUIDs of the drives for my fstab, but that’s up to you.
  10. Unmount everything and try to boot
  11. For some reason, Grub completely found the wrong hard drive, which brought me to a grub rescue> prompt.  I made it boot by using the following (my USB was on hd0 — YMMV):
    1. set root=(hd0,msdos1)
    2. set prefix=/boot/grub
    3. insmod normal
    4. normal
  12. Now you should have the normal Grub menu.  Then, I had to manually edit the default menu item, by pressing e.
    1. I replaced all instances of hd1,msdos1 with hd0,msdos1, and for some reason it was mounting my F2FS partition as ro — I changed that to rw.
  13. Now hit Ctrl+X to boot
  14. If all goes according to plan, this should boot into the Debian system.
  15. I re-installed Grub for good measure: grub-install /dev/sdX && update-grub2
  16. Now, I had to manually edit /boot/grub/grub.cfg to make the changes I specified above — replacing hd1,msdos1 with hd0,msdos1, and setting my F2FS partition as rw
    1. NOTE: these changes will be overridden whenever update-grub2 is run (either by you or by updating your packages).  This is why I said I “haven’t worked out all the kinks” yet.  This is only a temporary fix.


Generating a .NET DLL for use with VBA

This process will allow you to generate a single DLL that contains an embedded type library as well as a COM-exposed .NET library, and be used in Tools->References in VBA.  It can be used without registering the COM object with REGASM.

I may not find the time to add detail to this, but I am putting it here as a reminder for myself.  I implemented this as a proof-of-concept, but haven’t done anything with it yet. If anyone viewing this needs help with it, feel free to leave a comment with Disqus below.

Process Overview

  1. Develop a .NET COM-visible DLL.  Note that you don’t need to use REGASM to register it for this process.
    1. COM visibility is needed to interop with Office products.  If the DLL isn’t COM-visible, VBA can’t “see” its objects and methods
  2. Add the UnmanagedExports NuGet to your project
  3. Add a static method to your class to instantiate your COM object
  4. Decorate the static method with the [DllExport] attribute (from the UnmanagedExports library)

    using RGiesecke.DllExport;
    using System.Runtime.InteropServices;
    public class MyCOMObject : IMyCOMObject
      //COM Implementation
      [DllExport("CreateMyCOMObject", CallingConvention = CallingConvention.StdCall)]
      public static IMyCOMObject CreateMyCOMObject()
        return new MyCOMObject();
  5. Compile the DLL (NOTE: must be in x86 or x64 mode; Any CPU will not work with UnmanagedExports!)
  6. Generate a type library (tlbexp)
  7. Generate an IDL file by opening the TLB file with the OLE/COM Object Viewer (File->View TypeLib…)
    1. Note the OLE/COM object viewer (oleview.exe) comes with the Windows SDK, so it must be installed
  8. Export the type library to a .IDL file (Save As…)
  9. Edit the IDL file to add a module section, before the closing bracket in the library definition:

    library MyVBALibrary
      //Your new entry starts here
      module MyLibrary
          helpstring("Static method that instantiates a new instance of your COM object"),
        IMyCOMObjectsInterface __stdcall CreateMyCOMObject();
      //Your entry ends here
  10. Compile the IDL file into a new tlb file (note this is different than the TLB file already generated!!). Make sure you put it into a subfolder, because the midl tool won’t overwrite the original .tlb.
    midl /output .\outputsubfolder\ MyVBALibrary.idl
  11. Create a new resource file (e.g. MyVBALibrary.rc), and add a single line:
    1 typelib "MyVBALibrary.tlb"
  12. Move the .tlb file from the subdirectory into your current working directory (overwriting the old tlb file)
  13. Compile the .rc file:
    rc MyVBALibrary.rc
  14. This should create a new .res file, e.g. MyVBALibrary.res
  15. Assuming your project is a C# project; go to the project properties->Applicaton tab, and under “Resources,” click the “Resource File.” radio button.  Click the ellipsis (…), and select the MyVBALibrary.res file you generated in the previous step
  16. Recompile the project

Now, this dll can be used in your VBA project by adding a reference to it in Tools->References.  To instantiate a new .NET object from your COM class, use the CreateMyCOMObject() function you created.


The DLL must be in the path that VBA is searching for, or you will get a “File Not Found” exception.   You may have to use “ChDrive” and “ChDir” in your VBA code to find the DLL, as it will look in its current folder.


How To Make C DLL More Accessible to VB with a Type Library

Unmanaged Exports

Google Chrome in a Docker Container

(with sound and WebGL!)

If you’re a Linux enthusiast and haven’t already hopped on the Docker bandwagon, do.  Docker containers are a great way to deploy your web-based applications, or test out untrusted code, but they can also be used as a way to run apps on your Linux desktop that you might not fully trust.  It’s kind of like running your applications in a plastic bag — it makes it harder for them to break out and destroy your system.

Let’s run Google Chrome in a Docker container.

I will assume you are using Ubuntu 14.10.  First, install the latest Docker.  This tutorial expects Docker 1.4.1+.

Now, as a normal (unprivileged) user with sudo access, run the following commands in a shell:

sudo docker run transistor1/chrome config >
sudo chmod +x

You should be prompted for your sudo password, to run the Docker container.  That’s it! For subsequent runs, you can just run the



Now, head on over to Chrome Experiments, and test out your WebGL and sound. Enjoy!