kayforkind/skill-slice/3d-vase-mode-art

Claude Code and agent skill by kayforkind/skill-slice

Trust tier 3
  • community
Source check pending

Checking that the SKILL.md file is still in the repository.

Generates single-wall spiral vase STLs (sine, twisted polygon, Gielis superformula) and Bambu Studio/Cura/PrusaSlicer Spiralize Outer Contour settings for decorative prints, LED lamp shades, and manual/gradient multi-color bands. Use when the user asks for vase mode, spiral vase, parametric vase STLs, or translucent lamp-shade prints. Not for tabletop miniatures (3d-miniature-figurine), photo-to-mesh conversion (3d-image-to-model), or AMS automatic color swaps on a pure spiral path.

Install

npx vskill@latest install kayforkind/skill-slice/3d-vase-mode-art

SKILL.md

The same SKILL.md was published earlier as kayforkind/skill-slice/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.

AspectStandard PrintingVase Mode
LayersDiscrete start/stop per layerContinuous Z-rise spiral
WallsMultiple perimeters + infillSingle outer wall only
Z-SeamVisible vertical lineEliminated entirely
Top layersSolid top shellNone (open top)
InfillConfigurable percentage0% (hollow)
SpeedNormalOften faster (no travel moves)
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)
powershell
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
GoalRecommended Approach
Simple twisted shapesOpenSCAD with linear_extrude
Complex math surfacesPython with numpy-stl
Exotic organic shapesSuperformula generator
Polygon cross-sectionsTwisted polygon generator
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:

powershell
python generate_sine_vase.py
python
"""
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:

powershell
python generate_twisted_polygon_vase.py
python
"""
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:

powershell
python generate_superformula_vase.py
python
"""
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

This is the start of the file. Read the full SKILL.md on GitHub.

Security

  • Security scanPassed, 95 of 100Pattern checks on the skill's files.
  • Model reviewPassed

Quality evaluation

  • Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

Source

Popularity

7-day trend score
5

Not refreshed yet.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

  • Claude Code
  • Cursor
  • GitHub Copilot
  • Windsurf
  • Codex
  • Gemini CLI
  • Cline
  • Amp
  • Roo Code
  • Goose
  • Continue
  • Kilo Code
  • Junie
  • Trae
  • OpenHands
  • Qwen Code
  • AI Agent
  • Tabnine Chat
  • Sourcegraph Cody
  • Amazon Q
  • Firebase Genkit
  • Sweep
  • Devin
  • Phind
  • Mentat
  • Claude Desktop
  • Aider
  • GPT Pilot
  • Plandex
  • bolt.new
  • v0
  • Replit Agent
  • Anse
  • TypingMind
  • BetterChatGPT
  • LibreChat
  • Warp AI
  • Pieces
  • Fig AI
Embed badge
vskill VERIFIED badge
[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/kayforkind/skill-slice/3d-vase-mode-art/badge)](https://verified-skill.com/skills/kayforkind/skill-slice/3d-vase-mode-art)

Something wrong with this skill or its page? Tell us.