PPTX Presentation Generator

Use this skill whenever creating PPTX slides, presentations, or decks. Covers 30 modern design styles (Glassmorphism, Neo-Brutalism, Bento Grid, Dark Academia, Gradient Mesh, Claymorphism, Swiss International, Aurora Neon Glow, Retro Y2K, Nordic Minimalism, Typographic Bold, Duotone Color Split, Monochrome Minimal, Cyberpunk Outline, Editorial Magazine, Pastel Soft UI, Dark Neon Miami, Hand-crafted Organic, Isometric 3D Flat, Vaporwave, Art Deco Luxe, Brutalist Newspaper, Stained Glass Mosaic, Liquid Blob Morphing, Memphis Pop Pattern, Dark Forest Nature, Architectural Blueprint, Maximalist Collage, SciFi Holographic Data, Risograph Print) with exact color, font, and layout specifications. Activate for any presentation request including words like "sleek", "modern", "trendy", "designed", "stylish", or "visually striking" slides. Also trigger when users want to make existing slides "look better", need a specific aesthetic for a deck, or ask about presentation design in general.

Reading Style Specs

references/styles.md contains all 30 styles (~1200 lines). Do NOT read the entire file.

1. Grep for the style heading: ## XX. Style Name
2. Read only that section (~40 lines) until the next --- separator
3. Extract: background, colors (HEX), fonts, layout rules, signature elements, and avoid list

Font Strategy

python-pptx embeds font names in the PPTX XML, but fonts must be installed on the machine that opens the file to render correctly. If missing, the viewer app substitutes a default (usually Calibri), which breaks the intended design.

Read references/font-fallback.md for the full mapping table. The key principle:

• Ask the user if they have specific fonts installed
• Default to safe fonts (Arial, Calibri, Georgia, Courier New) when unsure
• Document which fonts the deck uses so the user can install them if needed

PPTX Generation with python-pptx

Setup

pip install python-pptx

Generate a standalone Python script for each presentation. The script should be self-contained, import everything it needs, and save the .pptx at the end.

Slide Dimensions (16:9 widescreen)

from pptx import Presentation
from pptx.util import Inches, Pt, Emu
from pptx.dml.color import RGBColor
from pptx.enum.text import PP_ALIGN
from pptx.enum.shapes import MSO_SHAPE
from pptx.oxml.ns import qn

prs = Presentation()
prs.slide_width = Inches(13.333)
prs.slide_height = Inches(7.5)

Blank Slide

Always use the blank layout (index 6) so no default placeholders interfere with custom design:

slide = prs.slides.add_slide(prs.slide_layouts[6])

Solid Background

bg = slide.background
fill = bg.fill
fill.solid()
fill.fore_color.rgb = RGBColor(0x0F, 0x0F, 0x2D)

Gradient Background

fill = slide.background.fill
fill.gradient()
fill.gradient_stops[0].color.rgb = RGBColor(0x1A, 0x1A, 0x4E)
fill.gradient_stops[0].position = 0.0
fill.gradient_stops[1].color.rgb = RGBColor(0x6B, 0x21, 0xA8)
fill.gradient_stops[1].position = 1.0

Shape with Transparency

Transparency is the key to styles like Glassmorphism and Pastel Soft UI. python-pptx doesn't expose alpha directly, so manipulate the XML.

Important: shape.fill._fill is a wrapper object, NOT an XML element — calling .find() on it will raise AttributeError. Always traverse from shape._element:

shape = slide.shapes.add_shape(
    MSO_SHAPE.ROUNDED_RECTANGLE, left, top, width, height
)
shape.fill.solid()
shape.fill.fore_color.rgb = RGBColor(0xFF, 0xFF, 0xFF)

# Set transparency via XML: val in 0-100000 (100000 = fully transparent)
solid_fill = shape._element.find('.//' + qn('a:solidFill'))
srgb = solid_fill.find(qn('a:srgbClr'))
alpha = srgb.makeelement(qn('a:alpha'), {'val': '20000'})  # 20% opacity
srgb.append(alpha)

Text with Custom Font

tf = shape.text_frame
tf.word_wrap = True
p = tf.paragraphs[0]
p.text = "Title Text"
p.font.size = Pt(36)
p.font.name = "Calibri Light"  # Use fallback-safe font
p.font.color.rgb = RGBColor(0xFF, 0xFF, 0xFF)
p.font.bold = True
p.alignment = PP_ALIGN.CENTER

Decorative Shapes

# Circle
circle = slide.shapes.add_shape(MSO_SHAPE.OVAL, left, top, size, size)

# Thin line (as a narrow rectangle)
line = slide.shapes.add_shape(MSO_SHAPE.RECTANGLE, left, top, width, Pt(2))

# Remove outline from shape
shape.line.fill.background()

Saving

output_path = "presentation.pptx"
prs.save(output_path)
print(f"Saved: {output_path}")

Design Principles

These matter because they're the difference between a professional-looking deck and a collection of text boxes:

• No text-only slides — every slide needs at least one visual element (shape, color block, decorative line). Even a simple colored rectangle behind the title transforms the slide from "document" to "presentation."
• Repeat signature elements — each style has 2-3 defining visual motifs. Use them consistently across all slides. This is what makes a deck feel cohesive rather than a random collection of slides.
• Exact HEX values — use the colors from the style spec precisely. "Close enough" colors break aesthetic cohesion, especially in dark-background styles where small differences are very visible.
• Font pairing matters — typography drives ~50% of the style impression. Match the title/body/caption font combination from the spec (using fallbacks where needed).
• Layer with intention — background → decorative shapes → content cards → text. z-ordering creates depth and professionalism.

Typical Slide Structure

1. Title slide — style's signature treatment at full impact
2. Agenda/overview — lighter use of signature elements
3. Content slides — consistent layout with style elements framing content
4. Data/chart slides — style colors applied to any charts or data
5. Closing slide — echo of title slide treatment

Available Styles (30)

For detailed color/font/layout specs → references/styles.md (read only the section you need) For font mapping → references/font-fallback.md