3d Vase Mode Art

Vase Mode / Spiral Art for 3D Printing

Overview

Vase mode — also called Spiralize Outer Contour (Cura/Bambu Studio) or Spiral Vase (PrusaSlicer) — is a specialized 3D printing technique that produces hollow, single-walled objects in one continuous, uninterrupted spiral motion. The printer head never retracts or lifts; the Z-axis rises gradually as the nozzle traces the outer contour, producing one continuous strand of filament from bottom to top.

Requirements and Limitations

• Model must have a single, continuous cross-section at every height
• No overhangs, handles, bridges, or detached internal geometry
• No multiple shells or internal cavities
• Bottom layers are printed normally (3–5 solid layers for a stable base)
• Objects are inherently fragile — single-wall thickness only
• Best suited for decorative rather than functional objects

Ideal Objects

• Vases and planters
• Lamp shades and light diffusers
• Pencil/pen holders
• Sculptural art pieces
• Decorative bowls
• Geometric sculptures
• Candle holders

When to Use

Trigger this skill when the user mentions any of:

• "vase mode", "spiral vase", "spiralize outer contour"
• Generating parametric or mathematical vase STLs
• Bambu Studio / PrusaSlicer / Cura vase mode settings
• LED lamp shade 3D printing
• Multi-color vase printing workarounds
• OpenSCAD or Python vase generation
• Superformula / Gielis surface generation for 3D printing

Prerequisites

Python Environment (for STL generation)

pip install numpy numpy-stl

Slicer

• Bambu Studio (primary reference; 2.0+ recommended for Smooth Spiral)
• PrusaSlicer or Cura also support equivalent "Spiral Vase" mode

Windows Host Notes

• Commands shown are PowerShell-compatible
• Python scripts can be saved anywhere; run from the project directory
• STL output paths should use backslashes or forward slashes — both work in Python on Windows

Procedure

Step 1: Determine the Goal

Identify what the user wants to create:

1. Decorative vase — standard single-wall object
2. Lamp shade — translucent material, even wall thickness, LED integration
3. Planter — thicker walls, more bottom layers
4. Sculptural art — exotic mathematical surfaces

Step 2: Select the Generation Approach

Step 3: Mathematical Surface Generation

A vase is a surface of revolution where the radius varies as a function of both height (z) and angle (θ).

Core Parametric Equations

x(θ, z) = r(θ, z) · cos(θ + twist(z))
y(θ, z) = r(θ, z) · sin(θ + twist(z))
z(θ, z) = z

Where r(θ, z) is the radius function and twist(z) adds rotational offset.

Common Radius Functions

Simple Sine Wave Vase:

r(θ, z) = base_radius + amplitude · sin(n · θ + phase · z)

• n controls the number of lobes around the circumference
• phase · z rotates the pattern as height increases (twist)
• amplitude controls the depth of the wave

Twisted Polygon Vase:

r(θ, z) = base_radius / cos(mod(θ + twist_rate · z, 2π/sides) - π/sides)

• Creates a polygon cross-section that twists with height
• sides = number of polygon sides
• twist_rate = radians of rotation per unit height

Fractal/Noise Vase:

r(θ, z) = base_radius + Σ(aᵢ · sin(nᵢ · θ + φᵢ · z))

• Sum of multiple sine waves at different frequencies creates organic, fractal-like surfaces
• Each term i has its own amplitude aᵢ, frequency nᵢ, and phase φᵢ

Superformula Vase (Gielis Superformula):

r(θ) = ( |cos(m·θ/4)/a|^n2 + |sin(m·θ/4)/b|^n3 )^(-1/n1)

• Generates an enormous variety of natural-looking shapes
• Parameters m, n1, n2, n3, a, b control the form

Step 4: Generate the STL

4a. Sine Wave Vase Generator

Save as generate_sine_vase.py and run:

python generate_sine_vase.py

"""
Parametric Sine Wave Vase Generator
Generates a single-shell STL suitable for vase mode printing.
"""
import numpy as np
from stl import mesh

def generate_sine_vase(
    height: float = 100.0,
    base_radius: float = 30.0,
    amplitude: float = 8.0,
    lobes: int = 5,
    twist_rate: float = 0.03,
    z_profile_func=None,
    n_theta: int = 200,
    n_z: int = 300,
    output_file: str = "sine_vase.stl",
) -> None:
    """
    Generate a sine-wave vase and export as STL.

    Args:
        height: Total vase height in mm.
        base_radius: Average radius in mm.
        amplitude: Sine wave amplitude in mm.
        lobes: Number of sine lobes around circumference.
        twist_rate: Twist in radians per mm of height.
        z_profile_func: Optional callable(z, height) -> scale factor for radius.
        n_theta: Angular resolution (number of points around circumference).
        n_z: Vertical resolution (number of layers).
        output_file: Output STL filename.
    """
    if z_profile_func is None:
        # Default: slight hourglass shape
        def z_profile_func(z: float, h: float) -> float:
            t = z / h
            return 0.7 + 0.6 * (t - 0.3) ** 2

    theta = np.linspace(0, 2 * np.pi, n_theta, endpoint=False)
    z_vals = np.linspace(0, height, n_z)

    # Build vertex grid: shape (n_z, n_theta, 3)
    vertices = np.zeros((n_z, n_theta, 3))
    for i, z in enumerate(z_vals):
        profile_scale = z_profile_func(z, height)
        twist = twist_rate * z
        for j, th in enumerate(theta):
            r = (base_radius + amplitude * np.sin(lobes * th + twist * lobes)) * profile_scale
            vertices[i, j, 0] = r * np.cos(th + twist)
            vertices[i, j, 1] = r * np.sin(th + twist)
            vertices[i, j, 2] = z

    # Build triangular faces
    faces = []
    for i in range(n_z - 1):
        for j in range(n_theta):
            j_next = (j + 1) % n_theta
            # Two triangles per quad
            v0 = vertices[i, j]
            v1 = vertices[i, j_next]
            v2 = vertices[i + 1, j_next]
            v3 = vertices[i + 1, j]
            faces.append([v0, v1, v2])
            faces.append([v0, v2, v3])

    # Add bottom cap
    bottom_center = np.array([0.0, 0.0, 0.0])
    for j in range(n_theta):
        j_next = (j + 1) % n_theta
        faces.append([bottom_center, vertices[0, j_next], vertices[0, j]])

    # Convert to numpy-stl mesh
    face_array = np.array(faces)
    stl_mesh = mesh.Mesh(np.zeros(face_array.shape[0], dtype=mesh.Mesh.dtype))
    for i, f in enumerate(face_array):
        stl_mesh.vectors[i] = f

    stl_mesh.save(output_file)
    print(f"Saved vase to {output_file} ({len(face_array)} triangles)")


if __name__ == "__main__":
    # Example 1: Classic sine wave vase
    generate_sine_vase(
        height=120,
        base_radius=35,
        amplitude=10,
        lobes=6,
        twist_rate=0.02,
        output_file="classic_sine_vase.stl",
    )

    # Example 2: Dramatic twist vase
    generate_sine_vase(
        height=150,
        base_radius=30,
        amplitude=5,
        lobes=4,
        twist_rate=0.08,
        output_file="twisted_vase.stl",
    )

    # Example 3: Organic profile vase
    def organic_profile(z: float, h: float) -> float:
        t = z / h
        return 0.5 + 0.5 * np.sin(t * np.pi) + 0.1 * np.sin(3 * t * np.pi)

    generate_sine_vase(
        height=130,
        base_radius=40,
        amplitude=12,
        lobes=7,
        twist_rate=0.04,
        z_profile_func=organic_profile,
        output_file="organic_vase.stl",
    )

4b. Twisted Polygon Vase Generator

Save as generate_twisted_polygon_vase.py and run:

python generate_twisted_polygon_vase.py

"""
Twisted Polygon Vase Generator
Creates a polygon cross-section that twists along the Z axis.
"""
import numpy as np
from stl import mesh

def generate_twisted_polygon_vase(
    height: float = 120.0,
    radius: float = 35.0,
    sides: int = 5,
    twist_degrees: float = 90.0,
    corner_radius: float = 3.0,
    n_theta: int = 200,
    n_z: int = 250,
    output_file: str = "twisted_polygon_vase.stl",
) -> None:
    """
    Generate a twisted polygon vase.

    Args:
        height: Vase height in mm.
        radius: Inscribed circle radius in mm.
        sides: Number of polygon sides.
        twist_degrees: Total twist from bottom to top.
        corner_radius: Smoothing radius for corners.
        n_theta: Angular resolution.
        n_z: Vertical resolution.
        output_file: Output filename.
    """
    twist_total = np.radians(twist_degrees)
    theta = np.linspace(0, 2 * np.pi, n_theta, endpoint=False)
    z_vals = np.linspace(0, height, n_z)

    vertices = np.zeros((n_z, n_theta, 3))
    for i, z in enumerate(z_vals):
        t = z / height
        twist = twist_total * t
        # Slight taper: wider in middle
        scale = 0.8 + 0.4 * np.sin(t * np.pi)
        for j, th in enumerate(theta):
            # Polygon radius with smoothed corners
            angle_in_sector = ((th + twist) % (2 * np.pi / sides)) - np.pi / sides
            r = radius / np.cos(angle_in_sector)
            # Smooth corners using min with circle
            r = min(r, radius + corner_radius)
            r *= scale
            vertices[i, j, 0] = r * np.cos(th)
            vertices[i, j, 1] = r * np.sin(th)
            vertices[i, j, 2] = z

    # Build faces
    faces = []
    for i in range(n_z - 1):
        for j in range(n_theta):
            j_next = (j + 1) % n_theta
            v0, v1 = vertices[i, j], vertices[i, j_next]
            v2, v3 = vertices[i + 1, j_next], vertices[i + 1, j]
            faces.append([v0, v1, v2])
            faces.append([v0, v2, v3])

    # Bottom cap
    center = np.array([0.0, 0.0, 0.0])
    for j in range(n_theta):
        j_next = (j + 1) % n_theta
        faces.append([center, vertices[0, j_next], vertices[0, j]])

    face_array = np.array(faces)
    stl_mesh = mesh.Mesh(np.zeros(face_array.shape[0], dtype=mesh.Mesh.dtype))
    for i, f in enumerate(face_array):
        stl_mesh.vectors[i] = f

    stl_mesh.save(output_file)
    print(f"Saved twisted polygon vase to {output_file}")


if __name__ == "__main__":
    generate_twisted_polygon_vase(sides=5, twist_degrees=90, output_file="pentagon_twist.stl")
    generate_twisted_polygon_vase(sides=3, twist_degrees=120, output_file="triangle_twist.stl")
    generate_twisted_polygon_vase(sides=6, twist_degrees=60, output_file="hexagon_twist.stl")

4c. Superformula Vase Generator

Save as generate_superformula_vase.py and run:

python generate_superformula_vase.py

"""
Superformula Vase Generator
Uses the Gielis superformula for exotic natural shapes.
"""
import numpy as np
from stl import mesh

def superformula(theta: float, m: float, n1: float, n2: float, n3: float,
                 a: float = 1.0, b: float = 1.0) -> float:
    """Compute the Gielis superformula radius for a given angle."""
    t1 = np.abs(np.cos(m * theta / 4.0) / a)
    t2 = np.abs(np.sin(m * theta / 4.0) / b)
    r = (t1 ** n2 + t2 ** n3) ** (-1.0 / n1)
    return r

def generate_superformula_vase(
    height: float = 120.0,
    scale: float = 30.0,
    m: float = 6.0,
    n1: float = 1.0,
    n2: float = 1.0,
    n3: float = 1.0,
    twist_rate: float = 0.02,
    n_theta: int = 300,
    n_z: int = 300,
    output_file: str = "superformula_vase.stl",
) -> None:
    """Generate a vase using the Gielis superformula cross-section."""
    theta = np.linspace(0, 2 * np.pi, n_theta, endpoint=False)
    z_vals = np.linspace(0, height, n_z)

    vertices = np.zeros((n_z, n_theta, 3))
    for i, z in enumerate(z_vals):
        t = z / height
        twist = twist_rate * z
        profile = 0.6 + 0.8 * np.sin(t * np.pi)
        for j, th in enumerate(theta):
            r = superformula(th + twist, m, n1, n2, n3) * scale * profile
            vertices[i, j, 0] = r * np.cos(th)
            vertices[i, j, 1] = r * np.sin(th)
            vertices[i, j, 2] = z

    faces = []
    for i in range(n_z - 1):
        for j in range(n_theta):
            j_next = (j + 1) % n_theta
            v0, v1 = vertices[i, j], vertices[i, j_next]
            v2, v3 = vertices[i + 1, j_next], vertices[i + 1, j]
            faces.append([v0, v1, v2])
            faces.append([v0, v2, v3])

    center = np.array([0.0, 0.0, 0.0])
    for j in range(n_theta):
        j_next = (j + 1) % n_theta
        faces.append([center, vertices[0, j_next], vertices[0, j]])

    face_array = np.array(faces)
    stl_mesh = mesh.Mesh(np.zeros(face_array.shape[0], dtype=mesh.Mesh.dtype))
    for i, f in enumerate(face_array):
        stl_mesh.vectors[i] = f

    stl_mesh.save(output_file)
    print(f"Saved superformula vase to {output_file}")


if __name__ == "__main__":
    # Starfish shape
    generate_superformula_vase(m=5, n1=2, n2=7, n3=7, output_file="starfish_vase.stl")
    # Flower petal shape
    generate_superformula_vase(m=8, n1=0.5, n2=0.5, n3=8, output_file="flower_vase.stl")
    # Organic blob
    generate_superformula_vase(m=3, n1=4.5, n2=10, n3=10, output_file="organic_blob_vase.stl")

4d. OpenSCAD Twisted Vase (Alternative)

For simple shapes without Python, use OpenSCAD:

// Twisted Star Vase for Vase Mode
$fn = 200;

height = 120;
base_r = 30;
lobes = 5;
amplitude = 8;
twist = 90; // degrees total twist

module vase_slice(z) {
    t = z / height;
    profile = 0.6 + 0.8 * sin(t * 180);
    twist_angle = twist * t;

    rotate([0, 0, twist_angle])
    hull() {
        for (a = [0:360/lobes:359]) {
            rotate([0, 0, a])
            translate([base_r * profile + amplitude * profile, 0, 0])
            circle(r = 0.5);
        }
    }
}

module vase() {
    step = 0.5;
    for (z = [0:step:height]) {
        translate([0, 0, z])
        linear_extrude(height = step + 0.01)
        vase_slice(z);
    }
}

vase();

Step 5: Profile Functions for Z-Axis Shaping

Use these as the z_profile_func parameter in the sine wave generator:

# Hourglass: narrow in the middle
def hourglass(z: float, h: float) -> float:
    t = z / h
    return 0.6 + 0.8 * (2 * t - 1) ** 2

# Trumpet: flares at the top
def trumpet(z: float, h: float) -> float:
    t = z / h
    return 0.5 + 1.5 * t ** 2

# Bulge: wide belly
def bulge(z: float, h: float) -> float:
    t = z / h
    return 0.6 + 0.8 * np.sin(t * np.pi)

# S-curve: two bulges
def s_curve(z: float, h: float) -> float:
    t = z / h
    return 0.6 + 0.4 * np.sin(2 * t * np.pi)

# Straight cylinder
def cylinder(z: float, h: float) -> float:
    return 1.0

# Tapered cone
def cone(z: float, h: float) -> float:
    t = z / h
    return 0.5 + t

Step 6: Configure Bambu Studio Vase Mode Settings

1. Open Bambu Studio and load your model
2. Go to Process Settings → Others tab
3. Under Special Mode, enable Spiral Vase
4. Enable Smooth Spiral (available in Bambu Studio 2.0+) to eliminate Z-seam artifacts

Automatic adjustments when enabled:

• Wall loops: 1
• Top shell layers: 0
• Infill density: 0%
• Only bottom layers remain solid

Recommended settings by application:

Tips for better results:

• Wider lines (0.6mm+ on a 0.4mm nozzle) create thicker, more rigid walls
• Slower speeds on the outer wall improve surface quality, especially for translucent materials
• Increase flow by 5–10% to ensure good layer bonding with wider lines
• Use a textured plate for the first layer if using PLA to prevent sticking issues
• Ensure a stable base with enough bottom solid layers (at least 4)

Step 7: LED Lamp Shade Integration

Translucent Materials

Print Settings for Lamp Shades

• Layer height: 0.12–0.16 mm for smooth, even light diffusion
• Line width: 0.50–0.60 mm for consistent wall thickness
• Speed: 25–30 mm/s for outer wall clarity
• Temperature: 5–10°C lower than normal to reduce bubbling
• Dry filament: Moisture causes bubbles that scatter light unevenly

LED Integration Methods

1. Battery-powered LED puck: Place under the vase; simplest approach
2. LED strip coil: Wind an LED strip inside the vase base cavity
3. Dedicated lamp base: Design a separate base with LED holder socket
4. Smart bulb adapter: Design the vase top to fit a standard E26/E27 socket

Design Considerations

• Keep wall thickness uniform for even light distribution
• Avoid sharp corners that create bright spots
• Taller vases need a wider base for stability with LED hardware inside
• Geometric patterns (sine waves, polygons) create stunning shadow projections

Step 8: Multi-Color Vase Mode Techniques

The Limitation: Standard vase mode is a continuous single-path process. The printer cannot stop to purge filament (required for AMS color switching) without creating a visible seam or scar in the wall. Therefore, automated multi-color is not natively supported in pure spiral vase mode.

Workarounds:

1. Manual Filament Swap (Pause Method)

   • Insert a Pause or Filament Change at a specific layer height in the slicer
   • When the printer pauses, cut and manually swap the filament
   • Creates a visible color transition line at the change point
   • Best for horizontal color bands (bottom half one color, top half another)

2. Gradient / Rainbow Filament

   • Use multi-color or gradient filament (e.g., rainbow PLA, tri-color silk)
   • Achieves smooth color transitions without any pauses
   • The transition pattern depends on the filament's color-change cycle length
   • Best for organic, flowing color effects

3. Filament Splicing

   • Manually splice different colored filament segments together on the same spool
   • Precise timing is difficult but allows planned color blocks
   • Use a filament welder or heat splice technique

4. Dual-Extruder Side-by-Side (Non-AMS)

   • Some printers support a second extruder for vase mode
   • One color per extruder, alternating per layer or section

Examples

Shape Catalog

Pitfalls

HARD RULES:

• Always generate watertight meshes with a solid bottom cap
• Never produce models with internal geometry, multiple shells, or detached cavities — the slicer will reject vase mode
• Test the STL in the slicer preview before recommending it for printing
• Do not recommend AMS automated color switching for pure spiral vase mode — it will create visible seams

Verification

Verify STL Generation

After running any generator script, confirm the output:

# Check file exists and has reasonable size
dir *.stl

# Quick Python check for mesh validity
python -c "from stl import mesh; m = mesh.Mesh.from_file('classic_sine_vase.stl'); print(f'Triangles: {len(m.vectors)}'); print(f'Closed: {m.is_closed()}')"

Expected output:

Triangles: 119800
Closed: True

(Triangle count will vary by parameters; is_closed() must return True.)

Verify Slicer Settings

In Bambu Studio after enabling Spiral Vase:

1. Confirm Wall loops = 1 (auto-set)
2. Confirm Top shell layers = 0 (auto-set)
3. Confirm Infill density = 0% (auto-set)
4. Confirm Smooth Spiral is enabled (Bambu Studio 2.0+)
5. Preview the toolpath — it should show a single continuous spiral with no Z-seam dots

Verify Print Readiness

• Slice the model and check the preview for any travel moves (there should be none in the spiral portion)
• Confirm bottom solid layers are present (3–6 depending on application)
• Confirm no top shell exists
• Check estimated print time is reasonable (vase mode is typically faster than standard)

Related Skills

• 3d-printing-fdm-basics — general FDM print setup and calibration
• bambu-studio-slicer-settings — detailed Bambu Studio configuration
• openscad-parametric-modeling — OpenSCAD for procedural geometry
• 3d-printing-materials-guide — filament selection including translucent materials