Wildenhain Turns Microsoft PowerPoint Into Turing-Complete Machine
Tom Wildenhain
PowerPoint animation triggers and layered shape cutouts function as optical memory registers, allowing presentations to execute universal computation on a single slide without external code.
AI-assisted summary of Great Impractical Ideas in Computer Science: PowerPoint Programming — original source. Check the original for full context.
Source published:
Key ideas
- PowerPoint is Turing-complete without external code or macros, achieving computation through layered slide elements, on-click triggers, and motion path animations. (9:46)
- Basic slide-to-slide hyperlink networks map directly to Deterministic Finite Automata (DFAs), but require exponential slide counts ($2^n$) to store multi-bit state. (3:32)
- The PowerPoint Morph transition can be coerced into smoothly warping arbitrary shapes and textures by first converting standard primitives into freeforms using shape union operations. (25:47)
- PowerPoint presentations saved as `.pptx` files are standard zip archives from which embedded high-resolution 3D models can be extracted directly as `.glb` files under the `/ppt/media/` directory. (33:44)
Detailed notes
## Background This video was published on YouTube by Tom Wildenhain on October 29, 2019. It documents a guest lecture he delivered for Carnegie Mellon University's Esoteric Programming Languages course, expanding on his creation of a PowerPoint Turing machine and other unconventional computing experiments within presentation software.
## TL;DR In this lecture, Tom Wildenhain explores the unexpected computational capabilities of Microsoft PowerPoint by treating the office suite tool as an esoteric programming environment. He walks through configuring PowerPoint as an IDE, modeling slide hyperlinks as Deterministic Finite Automata (DFAs), and using on-click animations and optical cutouts to construct a fully functional Turing machine that executes a binary palindrome recognizer. He also dives into unintended feature interactions, demonstrating text vectorization, 3D asset extraction from archive files, and complex vertex warping using the Morph transition, before closing with recursive slide zoom fractals.
## Atmosphere & style The presentation carries a deadpan, delightfully nerdy tone that treats an absurd premise with genuine academic rigor and software engineering curiosity. Wildenhain speaks in a casual, self-deprecating manner, routinely drawing laughs and banter from the university audience as he exposes bizarre edge cases and counterintuitive mechanics. Watching the talk feels like attending a lively, late-afternoon computer science seminar where a high-effort technical joke is pursued to its absolute logical extreme.
## Bulletin - [09:46](https://www.youtube.com/watch?v=_3loq22TxSc&t=586s) PowerPoint is Turing-complete without external code or macros, achieving computation through layered slide elements, on-click triggers, and motion path animations. - [03:32](https://www.youtube.com/watch?v=_3loq22TxSc&t=212s) Basic slide-to-slide hyperlink networks map directly to Deterministic Finite Automata (DFAs), but require exponential slide counts ($2^n$) to store multi-bit state. - [25:47](https://www.youtube.com/watch?v=_3loq22TxSc&t=1547s) The PowerPoint Morph transition can be coerced into smoothly warping arbitrary shapes and textures by first converting standard primitives into freeforms using shape union operations. - [33:44](https://www.youtube.com/watch?v=_3loq22TxSc&t=2024s) PowerPoint presentations saved as `.pptx` files are standard zip archives from which embedded high-resolution 3D models can be extracted directly as `.glb` files under the `/ppt/media/` directory.
## Key takeaways - [02:25](https://www.youtube.com/watch?v=_3loq22TxSc&t=145s) Configuring PowerPoint as an effective development environment requires increasing the undo limit to 100, disabling aggressive grid snapping, and setting up the Quick Access Toolbar. - [03:32](https://www.youtube.com/watch?v=_3loq22TxSc&t=212s) Slide hyperlinks can model any Deterministic Finite Automaton (DFA), where slides act as states and clickable zones serve as input transitions. - [06:01](https://www.youtube.com/watch?v=_3loq22TxSc&t=361s) Presentations can run as standalone desktop applications by disabling automatic mouse clicks, enabling kiosk presentation mode, and saving files in the `.ppsx` executable format. - [09:05](https://www.youtube.com/watch?v=_3loq22TxSc&t=545s) Slide-based DFAs suffer from exponential state explosion ($2^n$ slides for $n$ bits), necessitating on-click animation triggers to store state on a single slide. - [11:23](https://www.youtube.com/watch?v=_3loq22TxSc&t=683s) Layering duplicate objects and toggling visibility upon click events allows PowerPoint slides to simulate complex game logic and conditional interactions. - [14:09](https://www.youtube.com/watch?v=_3loq22TxSc&t=849s) PowerPoint determines initial object visibility based on the first animation assigned to it linearly in the animation pane, requiring dummy disappear animations to keep trigger targets hidden at launch. - [15:15](https://www.youtube.com/watch?v=_3loq22TxSc&t=915s) Duplicating an entire grouped memory cell automatically remaps internal animation triggers, enabling the rapid scaling of multi-bit registers. - [16:56](https://www.youtube.com/watch?v=_3loq22TxSc&t=1016s) The PowerPoint Turing Machine uses sliding tape layers, cutout apertures, and sequential stage blockers to cycle deterministically through Read, Write, Move, and State Transition phases. - [18:07](https://www.youtube.com/watch?v=_3loq22TxSc&t=1087s) A live palindrome recognizer demonstrates that complex algorithms can execute mechanically inside PowerPoint using only native animations and automated clicking. - [20:35](https://www.youtube.com/watch?v=_3loq22TxSc&t=1235s) External Python drivers can orchestrate PowerPoint slide computations to execute precompiled assembly instructions like an emulated CPU. - [22:56](https://www.youtube.com/watch?v=_3loq22TxSc&t=1376s) The Morph transition calculates edit-distance heuristics across slides, natively refusing to blend between different standard primitives unless control handles or vertex modifications are applied. - [31:19](https://www.youtube.com/watch?v=_3loq22TxSc&t=1879s) Applying shape union or fragment operations forces standard primitives and typography into editable freeform vector paths that Morph can warp continuously. - [28:21](https://www.youtube.com/watch?v=_3loq22TxSc&t=1701s) Invisible matching anchor text can be assigned to disparate objects to manually override PowerPoint's default proximity-based Morph matching heuristics. - [33:44](https://www.youtube.com/watch?v=_3loq22TxSc&t=2024s) High-fidelity 3D assets from Microsoft's catalog can be extracted from `.pptx` presentations by renaming the container to `.zip` and pulling raw `.glb` files from `/ppt/media/`. - [45:05](https://www.youtube.com/watch?v=_3loq22TxSc&t=2705s) Self-referencing Slide Zoom and Summary Zoom thumbnails form circular dependencies that render dynamic visual recursion and mathematical fractals within internal engine limits.
## Detailed walkthrough ### [00:06](https://www.youtube.com/watch?v=_3loq22TxSc&t=6s) Introduction and Motivations for PowerPoint Programming
Tom Wildenhain opens his guest lecture for Carnegie Mellon University's Esoteric Programming Languages course by acknowledging that although PowerPoint is often mocked, the audience will learn both practically useful techniques and things that are completely useless. He outlines the roadmap for the talk: covering basic PowerPoint programming principles, demonstrating how to build a Turing machine inside PowerPoint, and walking through advanced computational features. Before diving in, he surveys the room to see who has taken CMU's 15-251 (Great Theoretical Ideas in Computer Science).
```mermaid flowchart TD accTitle: Progression of PowerPoint Computation accDescr: Diagram illustrating the evolution of PowerPoint computing from DFA to a full Turing Machine. subgraph S1["Level 1: Slide Links"] DFA["Hyperlinks & Slides"] -->|"Finite Memory"| Reg["Deterministic Finite Automaton (DFA)"] end subgraph S2["Level 2: Rich Executable UI"] UI["Kiosk Mode &.ppsx"] --> App["Standalone Application Feel"] end subgraph S3["Level 3: Animations"] Trig["On-Click Animations"] --> TM["Turing-Complete Machine"] end Reg --> UI UI --> Trig ```
Addressing the obvious question of why anyone would ever try to program inside PowerPoint, Wildenhain shares two primary reasons: 1. **Childhood necessity**: In fourth grade, he was restricted to a Windows XP machine that only had basic utilities—the Microsoft Office suite, Paint, and Notepad. Since neither Notepad nor Paint permitted interactive computation, PowerPoint and Excel were the only creative outlets available. 2. **Feature density and accidental interactions**: PowerPoint includes an immense collection of overlapping features. In standard software engineering, edge cases are intentionally disabled, but PowerPoint often produces bizarre, emergent behavior when different tools interact. As Wildenhain notes: “And whenever you have a lot of features, they can interact with each other in different ways, and that gives you a lot of edge cases, and those edge cases often have very interesting behaviors in PowerPoint.”
He jokes about a study claiming PowerPoint actively degrades presentation quality, arguing that if it fails as presentation software, it should instead be put to better use as a development platform. He warns the audience about bad design habits—such as slapping unreadable text over busy background images or abusing haphazard animations—before pivoting to software development.
---
[02:25](https://www.youtube.com/watch?v=_3loq22TxSc&t=145s) Configuring PowerPoint as an IDE
Setting up PowerPoint as an Integrated Development Environment (IDE) is surprisingly fast—Wildenhain jokes that “setting up your PowerPoint IDE which is easier than Vim, which I think says a lot about Vim.” To make the environment suitable for real programming, three configuration tweaks are required:
- **Quick Access Toolbar customization**: By right-clicking frequently needed tools and pinning them to the top toolbar, developers can bypass menu digging during repetitive tasks. - **Increasing the undo limit**: Under `Options` $\rightarrow$ `Advanced`, PowerPoint defaults to only 20 undos. Wildenhain warns: “20 is like way too few undos to have to do real programming.” The limit should be maximized to its ceiling (100). - **Grid and snap settings**: Right-clicking the canvas reveals alignment settings. By default, shapes snap aggressively to one another. Turning grid-snapping off gives full pixel-level control and prevents elements from jumping away from where they need to sit.
---
[03:32](https://www.youtube.com/watch?v=_3loq22TxSc&t=212s) Logic via Hyperlinks and the DFA Equivalence
To introduce pure logic into a deck without external code, the foundational tool is the internal hyperlink. Elements can be assigned hyperlink actions targeting specific slides within the presentation, turning slide clicks into state transitions.
```mermaid flowchart LR accTitle: Four Digit Keypad State DFA accDescr: State diagram showing how 9 slides track digit count and error state. Start(("Start (Slide 1)")) -->|"Correct: 7"| S1["1 Digit OK"] Start -->|"Wrong digit"| E1["1 Digit Error"] S1 -->|"Correct: 1"| S2["2 Digits OK"] S1 -->|"Wrong digit"| E2["2 Digits Error"] E1 -->|"Any digit"| E2 S2 -->|"Correct: 3"| S3["3 Digits OK"] S2 -->|"Wrong digit"| E3["3 Digits Error"] E2 -->|"Any digit"| E3 S3 -->|"Correct: 1"| Acc(("Accept Slide")) S3 -->|"Wrong digit"| Rej(("Reject Slide")) E3 -->|"Any digit"| Rej ```
Wildenhain explains that this architecture is theoretically identical to a Deterministic Finite Automaton (DFA). A slide acts as an automaton state, while user-clickable regions correspond to input symbols causing transitions to new states. He demonstrates an interactive four-digit keypad where the target passcode is CMU’s internal code `7131` (representing 15-131, the Great Practical Ideas course). When asked how many slides are required to construct this keypad DFA, the room guesses high numbers, but Wildenhain points out that only 9 slides are necessary: - The system only needs to track two variables across each step: how many digits have been entered so far (0 through 4) and whether any mistake has occurred yet (correct path vs. error path). - Multiplying the 4 steps by the binary correctness flag, plus the start slide, yields exactly 9 distinct slides to handle all possible 4-digit input combinations.
---
[06:01](https://www.youtube.com/watch?v=_3loq22TxSc&t=361s) Converting Presentations into Standalone Applications
While slide-based DFAs work logically, default slideshow playback ruins the illusion of an application because stray clicks, mouse-wheel scrolls, or the bottom-left navigation widget trigger unintended slide skips. Wildenhain systematically resolves each user-experience flaw using built-in PowerPoint settings:
- **Disabling automatic slide advance**: Under the `Transitions` tab, look at `Advance Slide`. Both the `On Mouse Click` and `After [time]` checkboxes can be unchecked. Because these are checkboxes rather than mutual radio buttons, unchecking both freezes the screen, forcing navigation to happen strictly through defined hyperlinks. - **Kiosk presentation mode**: Under `Slide Show` $\rightarrow$ `Set Up Slide Show`, enabling `Browsed at a kiosk (full screen)` completely strips away the bottom slideshow navigation toolbar and ignores scroll wheel inputs. Wildenhain remarks: “Apparently Microsoft has a special mode where they predict you're going to use PowerPoint to make your interactive display at your store, and if you set it to that, then we can now notice that the toolbar is gone.” - **Stand-alone execution format (`.ppsx`)**: Normal `.pptx` files launch straight into the editing workspace. Saving the deck as a PowerPoint Show (`.ppsx`) makes the file launch directly into full-screen execution when double-clicked, closely mimicking a compiled binary. - **Dedicated exit action**: Because kiosk mode blocks keyboard escape routes and default window chrome, users become trapped unless an exit is explicitly wired up. Inserting a shape and configuring `Insert` $\rightarrow$ `Action` $\rightarrow$ `Hyperlink to: End Show` provides a clean in-app exit button.
---
[09:05](https://www.youtube.com/watch?v=_3loq22TxSc&t=545s) Memory Limitations and the Transition to Animations
Despite making a presentation behave like a desktop app, slide-level DFAs hit a severe computational bottleneck: state explosion. Wildenhain explains that tracking $n$ bits of storage in a pure slide DFA requires an exponential number of slides ($2^n$ distinct slides for $n$ bits of memory). Simulating even 10 bits of RAM requires $2^{10} = 1024$ manually linked slides, making sophisticated logic impossible with hyperlinks alone.
To overcome this exponential slide growth and achieve Turing-completeness within a compact deck, PowerPoint requires a mechanism that can store state *within* a single slide. Wildenhain reveals that the secret lies in PowerPoint’s trigger-based on-click animations.
[09:46](https://www.youtube.com/watch?v=_3loq22TxSc&t=586s) Event-Driven Slides and the Portal Game Demo
Tom Wildenhain introduces on-click animations as PowerPoint's equivalent of event-driven programming: they execute strictly when an element is clicked and directly alter the slide's state. To demonstrate how this works in practice, he pulls up a playground file themed around the video game *Portal*. The objective is simple: navigate the player character to an exit door. By linking animations to click triggers on specific objects, clicking the exit door causes the player character to disappear and victory text to display.
```mermaid flowchart LR accTitle: Portal Puzzle State Sequence accDescr: Sequence diagram showing how clicking objects updates slide state in PowerPoint.
subgraph S1["Initial State"] A["Click Cube"] --> B["Player Holds Cube"] end subgraph S2["Intermediate State"] B --> C["Button Becomes Clickable"] C --> D["Click Button: Drop Cube & Open Door"] end subgraph S3["Final State"] D --> E["Click Door: Level Clear"] end ```
A common pitfall arises immediately: PowerPoint assigns meaningless default labels to elements, such as "Picture 2", "Picture 4", and "Picture 5". Wildenhain points out that “this teaches us a very important lesson in PowerPoint programming, which is that you have to comment your code.” By opening the Selection Pane, developers can rename objects cleanly (e.g., "Door") so that click triggers point to the intended targets. Furthermore, to avoid requiring separate sequential clicks for each effect, related actions are tied together using the "With Previous" timing setting.
- On-click animations serve as discrete event listeners that modify slide state upon interaction. - Renaming assets in the Selection Pane functions as essential code documentation in PowerPoint development. - The "With Previous" animation trigger enables multiple visual and logical state transitions to occur simultaneously from a single click event.
---
[11:23](https://www.youtube.com/watch?v=_3loq22TxSc&t=683s) State Management and Object Layering
Expanding the *Portal* puzzle, Wildenhain explains how to enforce game rules through state management: the player should not be able to pass through the exit door until it has been opened by pressing a floor button, and the button itself must require placing a weighted storage cube on it first. When he asks the audience how to gate interactions so the door only becomes interactive after the button is pressed, an audience member suggests layering duplicate objects where a non-interactive front image disappears to reveal the clickable target beneath.
Wildenhain adopts this method, using duplicate visual elements stacked perfectly on top of one another to represent different operational states. Holding the cube is treated as a boolean variable—you either possess it or you do not. When the player clicks the cube, the original disappears, an icon of the player holding the cube appears, and an inert, non-interactive button is hidden to reveal an interactive button underneath. By using PowerPoint's built-in shape alignment tools, layered elements can be positioned with pixel precision so transitions between interactive and non-interactive states appear seamless.
---
[14:09](https://www.youtube.com/watch?v=_3loq22TxSc&t=849s) PowerPoint’s Internal Animation Resolution Logic
During the construction of the cube-and-button puzzle, an unexpected visual glitch occurs: assets that were meant to remain hidden at the start appear on the screen immediately. Wildenhain pauses to explain the quirks of PowerPoint's internal evaluation model: “it's actually a little bit underspecified when you set up a slide with animations what the starting state should be, because every element can either start on the slide or start off the slide.”
PowerPoint determines an element's initial visibility by scanning the animation pane linearly from top to bottom. It inspects the very first animation assigned to an object: - If the first animation assigned to an item is an exit effect (disappear), the object initializes as visible on the slide. - If the first animation assigned to an item is an entrance effect (appear), the object initializes as hidden off the slide.
While this heuristic works fine for linear slideshow presentations, it breaks down for on-click trigger groups because PowerPoint still evaluates the overall animation list in an arbitrary linear order. To force an element to start hidden when its first logical trigger is an entrance effect, the developer must explicitly prepend an instant "disappear" animation at the very top of the animation sequence.
---
[15:15](https://www.youtube.com/watch?v=_3loq22TxSc&t=915s) Simulating Multi-Bit Memory Registers
Wildenhain moves from simple puzzle triggers to building digital memory cells in PowerPoint. A memory module can be represented as a bank of mutually exclusive circles paired with trigger buttons. Clicking a specific button resets the state by hiding all circles except the one corresponding to the selected value.
```mermaid flowchart TD accTitle: Independent Memory Module Duplication accDescr: Diagram illustrating how copying grouped triggers preserves internal dependencies.
subgraph ModuleA["Memory Cell 1 (Bit A)"] btnA["State Buttons A"] -->|"Triggers"| circA["Indicator Circles A"] end
subgraph ModuleB["Memory Cell 2 (Bit B)"] btnB["State Buttons B"] -->|"Triggers"| circB["Indicator Circles B"] end
ModuleA -.->|"Duplicate Entire Group"| ModuleB ```
A crucial discovery in PowerPoint programming involves how the software handles object duplication. If an entire group containing both the buttons and the animated indicators is copied and pasted, PowerPoint automatically remaps the internal dependencies to the newly pasted copies. This produces an independent, self-contained multi-bit memory register without requiring any manual trigger reassignment. If only the indicators are copied without their trigger buttons, PowerPoint strips the triggers and dumps the animations at the top of the general animation pane.
In the design of the PowerPoint Turing Machine tape, this logic is inverted for physical interaction. Instead of making the selected bit visible, the active bit is turned transparent (invisible) while unselected bits remain opaque. This creates an optical "aperture" or cutout: - The tape slides across a static background containing detector zones. - The cutout exposes only the single underlying detector matching the active memory state. - Because only the exposed zone can be clicked through the hole, the machine eliminates the need for separate interactive buttons on every individual tape cell.
---
[16:56](https://www.youtube.com/watch?v=_3loq22TxSc&t=1016s) Architecture of the PowerPoint Turing Machine
Wildenhain presents the full, expanded architecture of the PowerPoint Turing Machine. The machine is assembled out of standard PowerPoint elements operating as an integrated mechanical computer:
```mermaid flowchart LR accTitle: Turing Machine Execution Loop accDescr: Flowchart of the execution stages enforced by blocking rectangles.
subgraph Hardware["Tape & Sensor Mechanism"] Tape["Memory Cells (Tape)"] Motion["Motion Paths (Left / Right)"] Sensors["Background Detector Holes"] Tape <--> Sensors Tape --> Motion end
subgraph Cycle["Instruction Cycle (Blocked Sequence)"] R["1. Read Data"] --> W["2. Write Data"] W --> M["3. Move Head"] M --> S["4. Transition State"] S --> R end
Hardware <--> Cycle ```
- **Tape Mechanism:** Composed of vertically stacked memory cells that translate horizontally across the slide using motion path animations. - **Optical Read/Write Detectors:** Cutout holes positioned directly behind the tape that expose interactive surfaces only where a cell contains an active bit. - **Instruction Sequencing Blockers:** Large transparent or opaque shapes that appear and disappear sequentially. These force the Turing cycle to strictly follow four discrete stages: Read $\rightarrow$ Write $\rightarrow$ Move $\rightarrow$ State Transition. - **Punch Card Transition Table:** A visual matrix of control instructions that defines state transitions and data writes for every machine state.
Because the sequence blockers shield every interactive element except the single valid target for the current processing stage, the user does not need to make any choices while clicking. Wildenhain notes that if you set up an automated mouse macro to click randomly across the slide, the presentation will execute its computation completely autonomously.
---
[18:07](https://www.youtube.com/watch?v=_3loq22TxSc&t=1087s) Live Execution: The Palindrome Recognizer
To demonstrate computational completeness, Wildenhain loads a complex Turing machine program designed to recognize binary palindromes. The demo begins with setting the input string directly onto the tape cells: setting bits creates transparent cutouts revealing orange background markers underneath. He configures an example input (such as $1001$) and initiates the machine cycle.
As the presentation advances, the stage blockers govern each computational step: 1. The read detector samples the leftmost character through the tape window. 2. The state changes to record the observed bit ($1$). 3. The tape fires a motion path animation to translate across the slide to find the corresponding bit at the end of the string. 4. The machine verifies that the final bit matches the stored bit, erases it, and shifts direction to repeat the process on the inner substring.
Watching the mechanical-like motion paths shift the tape back and forth, Wildenhain jokes, “you could argue that it's very intuitive because you get to see all the steps of the computation happening.” As the final bit is erased and the machine halts upon recognizing the complete palindrome, he marvels at the medium, remarking that rather than using PowerPoint just to present static slides about Turing machines, people should simply run the Turing machines inside PowerPoint itself.
[20:35](https://www.youtube.com/watch?v=_3loq22TxSc&t=1235s) Turing Machine Q&A: Quines, Compilers, and PowerPoint CPUs
An audience member opens the question-and-answer period by asking Tom Wildenhain if he has written a quine yet. Wildenhain chuckles at the thought, noting how agonizing that endeavor would be. He reflects on what that would even entail: to build a true quine, the PowerPoint Turing machine would have to output the binary representation of its own `.pptx` presentation file, which strikes him as the most reasonable interpretation. That would demand an enormous amount of tape memory, though in theory, running on an empty tape could produce the PowerPoint file as output. He also remarks on backwards compatibility, pointing out that his Turing machine works on versions all the way back to PowerPoint 2007. An audience member muses about emulating PowerPoint 2013 inside PowerPoint 2007, which Wildenhain notes would be significantly more difficult, particularly because rendering a visual display inside the Turing machine would require constructing a grid of tiny colored rectangles that toggle on and off. That would effectively require building an entire graphics adapter mechanism directly out of the Turing tape logic to drive a very low-resolution screen.
Another student asks whether someone could write a compiler that targets Microsoft PowerPoint. Wildenhain confirms that people have tackled related projects: someone had shared a link about attempting to build a dedicated compiler targeting PowerPoint presentations, but abandoned it because of the extreme complexity. Instead, that developer constructed a PowerPoint CPU:
> “Instead if they made a PowerPoint CPU where they can take it already like compiled assembly code and then they can have a—use the PowerPoint to do these calculations or they're like there's some like Python code which like inserts all the data into the PowerPoint then has it like add the numbers together and then reads the data back out of the PowerPoint...”
The external Python script orchestrates the input/output cycle, letting PowerPoint execute the underlying instructions and arithmetic before reading back the results.
```mermaid flowchart LR accTitle: PowerPoint CPU Workflow accDescr: Diagram illustrating how an external Python script interacts with PowerPoint to execute assembly code. subgraph Host ["External Environment"] A["Assembly Code"] --> B["Python Driver"] B -->|"Read outputs"| E["Result"] end subgraph Presentation ["PowerPoint CPU"] C["PowerPoint Slide State"] D["Slide Computation / Addition"] C --> D end B -->|"Inject data / instructions"| C D -->|"Updated slide state"| B ```
---
[22:56](https://www.youtube.com/watch?v=_3loq22TxSc&t=1376s) Exploiting the Morph Transition and Shape Interpolation
Wildenhain shifts gears away from Turing machines to explore unintended feature interactions across the software. He explains that PowerPoint perfectly illustrates the emergence of bizarre behavior when combining features that engineers never envisioned being used together. To demonstrate, he turns to PowerPoint's relatively modern Morph transition, which calculates an edit-distance heuristic between elements across two consecutive slides and smoothly animates the differences. Testing edge cases quickly reveals how that heuristic behaves:
> “So looks at the two slides, tries to find this sort of like edit distance between them, and then figures out what element to move, say, like transition one slide into the other.”
When two shapes sit on the first slide and one sits on the second, PowerPoint animates toward the closer object. If the color of the target shape changes, it adjusts the mapping based on combined visual attributes; changing colors again can cause it to snap back to the first object because its internal similarity metric now prefers that match. However, replacing the shapes entirely with a different geometry, such as transitioning a rectangle into a circle, breaks the effect—PowerPoint simply cross-fades rather than morphing the boundaries.
PowerPoint will only automatically interpolate between shapes if they share the exact same shape type. Wildenhain demonstrates that stretching or distorting a circle preserves the Morph animation seamlessly. He then inserts a star shape, which features a distinctive yellow control point that alters the depth and sharpness of its points. When he duplicates the star on the next slide and drastically adjusts its yellow handle, Morph interpolates the inner vertices cleanly.
- PowerPoint uses an internal heuristic akin to edit distance, factoring in position and color similarity to pair objects between slides. - Morph refuses to morph across disparate standard primitives (e.g., circle to rectangle) and falls back to a standard fade. - Adjusting shape geometry via yellow control handles still preserves Morph interpolation because the underlying object type remains identical.
---
[25:47](https://www.youtube.com/watch?v=_3loq22TxSc&t=1547s) Hacking Freeform Geometry and Texture Warping
The discovery that Morph animates internal vertex coordinates leads Wildenhain to test freeform shapes. If PowerPoint checks whether two objects share the same type before enabling point interpolation, then two wildly different hand-drawn freeform shapes should technically morph into one another. He jokes that any sensible programmer assigned to build the Morph transition would have explicitly disallowed freeform interpolation:
> “Now if you were like a sensible programmer given this task what you'd probably say is, okay, these freeform shapes can never interpolate between each other, like who's tasked with making freeform shapes interpolate between each other? We need—nobody needs it, but it's also like very difficult to make, but it's in there, so that's kind of interesting.”
Against expectations, PowerPoint executes a smooth, fluid mesh warp between the two arbitrary freeform silhouettes. Pushing the engine further, Wildenhain applies a bitmap picture fill to the freeform shape. When morphed across slides, PowerPoint does not merely reposition the boundary vertices—it computes an interior 2D texture warp across the entire interior surface so the image deforms along with the contour.
This unlocks a clever workaround to the earlier limitation where basic shapes refused to morph into each other. PowerPoint includes shape Boolean tools (Union, Combine, Fragment, Intersect, Subtract). By taking a standard circle or square and merging it with an overlapping shape, PowerPoint converts the resulting object into an arbitrary freeform polygon:
```mermaid flowchart TD accTitle: Freeform Morphing Bypass accDescr: Flow showing how unioning basic primitives forces PowerPoint to treat them as freeforms for morphing. subgraph Primitives ["Basic Shapes"] A["Circle / Rectangle"] B["Overlapping Shape"] end subgraph Boolean ["Shape Operations"] C["Merge / Union"] end subgraph Result ["Morph Pipeline"] D["Converted Freeform Shape"] E["Smooth Vertex & Texture Morph"] end A --> C B --> C C --> D D --> E ```
Once two completely different standard primitives are forced into freeform shapes through a union operation, the Morph transition can smoothly blend between them.
---
[28:21](https://www.youtube.com/watch?v=_3loq22TxSc&t=1701s) Character-Level Morphing and Hidden-Text Anchors
Wildenhain next examines how the Morph transition handles text. When text is embedded inside a shape and the shape changes across slides, the text initially just fades out. If identical text exists on both slides, PowerPoint will interpolate their positions. Morph also provides advanced effect options allowing transitions to track by Objects, Words, or Characters. By switching the setting to Characters, PowerPoint animates individual letters flying across the slide to reconstruct the words on the subsequent slide.
Wildenhain then reveals an ingenious trick for steering PowerPoint's object matching. When multiple similar shapes exist on a slide—such as multiple circles—Morph defaults to pairing them based on spatial proximity, which may not match what the designer wants. To force a shape on slide one to morph into an arbitrary shape on slide two regardless of distance:
1. Type a matching character string (such as the letter "X") into both target shapes to force the transition engine to prioritize them as a text match. 2. Remove the visual appearance of the label by setting the Text Fill to "No Fill" and Text Outline to "No Outline". 3. Because the text still exists in the object model, the transition engine treats the two shapes as an identical character match, smoothly morphing them across the screen while the anchor text remains completely invisible.
> “As long as it's the same exact text, now it's going to be forced to interpolate that instead because it has to—it has to have a text match.”
[31:19](https://www.youtube.com/watch?v=_3loq22TxSc&t=1879s) Vectorizing Text and Shape Merging in PowerPoint
Tom Wildenhain demonstrates unexpected capabilities in PowerPoint's shape operations by combining text boxes with native vector shapes. When a user selects two arbitrary shapes, PowerPoint can compute their union, generating a combined shape with editable vertex points. However, when taking a standard text box and computing a shape union with a circle, PowerPoint performs an unconventional operation: rather than merging the bounding rectangle with the circle, it outlines and traces the text characters themselves, converting the typography directly into vector shapes.
```mermaid flowchart LR accTitle: Text Vectorization Pipeline in PowerPoint accDescr: Process showing how text is converted into vector shapes or fragmented into isolated letters using shape operations. subgraph Input["Input Elements"] T["Text Box"] S["Vector Shape (Circle)"] end subgraph Operation["Shape Operations"] U["Shape Union"] F["Shape Fragment"] end subgraph Output["Output Geometry"] V["Vector Outlines of Text"] L["Individual Letter Shapes"] end
T --> U S --> U U --> V T --> F S --> F F --> L ```
By switching from union to the "Fragment" operation, PowerPoint cuts the text apart, turning each individual letter into its own distinct, manipulable vector object. When fragmented objects are altered, the Morph transition can distort and interpolate between them. Wildenhain notes that while vector design software like Illustrator is standard, PowerPoint functions as a surprisingly capable vector tool when someone needs to treat text as editable geometry rather than characters. Furthermore, animations created using these transitions can be rendered out using PowerPoint's built-in "Export to Video" functionality.
- Shape Union converts live typography into editable bezier paths rather than merging the text box frame. - Shape Fragment splits text strings into individually selectable, editable letter polygons. - Animations generated with vector manipulations can be exported directly via File > Export > Create a Video.
---
[33:44](https://www.youtube.com/watch?v=_3loq22TxSc&t=2024s) 3D Effects and Extracting Models from PowerPoint
Wildenhain turns to PowerPoint’s 3D rotation and bevel tools, which are often associated with dated presentation designs. Standard shape operations typically break when encountering 3D attributes—attempting to merge a 3D-styled shape will strip the effect and flatten it into 2D. However, applying the Morph transition to shapes with 3D effects prompts PowerPoint to calculate full three-dimensional spatial transformations, smoothly interpolating rotations and perspective shifts across slides.
```mermaid flowchart TD accTitle: Extracting 3D Models from PowerPoint Files accDescr: Step-by-step extraction workflow from PowerPoint's online catalog to raw GLB 3D asset files. A["Insert > 3D Models (Stock Catalog)"] --> B["Save presentation as.pptx"] B --> C["Rename file extension to.zip"] C --> D["Unzip archive and navigate to /ppt/media/"] D --> E["Extract model1.glb"] ```
Wildenhain shares his frustration with game development asset marketplaces: “I found it surprisingly difficult how like hard it is to get 3D assets... like all the assets are actually like really expensive and somewhat terrible.” He contrasts this with PowerPoint's built-in "Insert 3D Models" catalog, highlighting that the models available in Office 365 are remarkably high-resolution, complete with physically based materials and reflective lighting. Addressing the fact that the models appear trapped inside presentation files, he demonstrates an extraction hack: saving the presentation, changing the file extension from `.pptx` to `.zip`, unpacking the archive, and retrieving the embedded `model1.glb` file directly from the `/ppt/media/` directory. When an audience member raises licensing concerns, Wildenhain reasons: “I wouldn't be surprised that the licensing is pretty good because given that you're able to like include a PowerPoint presentation... I think that it probably has it set to be some type of royalty-free license.”
- Standard 2D shape merging strips 3D perspective, but the Morph transition supports full 3D spatial rotation. - PowerPoint packages stock models as standard binary glTF files (`.glb`) inside the Open Packaging Conventions (OPC) XML container. - Embedded media can be extracted without third-party converters simply by unpacking the PPTX archive.
---
[38:27](https://www.youtube.com/watch?v=_3loq22TxSc&t=2307s) Reverse Engineering Morph's Image Detection Algorithms
Investigating how Morph handles bitmap imagery, Wildenhain inserts an image, duplicates the slide, and crops the second instance to observe how the engine calculates the transition. Rather than crossfading between two static frames or stretching the bounding box, Morph performs a dynamic crop-and-zoom effect, focusing smoothly on the chosen sub-region. This behavior proves that PowerPoint tracks asset identities across slides to apply contextual transformations.
To test how PowerPoint verifies that two pictures are the same asset, Wildenhain conducts live experiments: - **Clipboard/Pipeline Ingestion**: Copying an image directly versus passing it through Microsoft Paint to strip internal metadata tags. - **Pixel-Based Differencing**: Testing whether PowerPoint executes an automated image hash or pixel-level image diff when asset references do not match. - **Scale and Dimension Thresholds**: Resizing an image by percentage steps (e.g., down to 70% or 99%) to locate the tolerance cutoff where Morph stops zooming and falls back to a standard crossfade.
When subtle modifications cause Morph to unexpectedly drop an object instead of animating it, Wildenhain reflects on the rabbit hole of testing office software: “All right, so you can see that you can spend a lot of time and waste a lot of time by a talk.” Additionally, he notes that PowerPoint’s shape merge tools can also be applied to images, allowing shapes to mask, subtract, and carve complex designs out of raster graphics. When asked if Morph can interpolate between two different 3D meshes, he clarifies that while PowerPoint will not morph arbitrary geometry topologies together, rotating and scaling the *same* 3D model across slides works reliably.
---
[45:05](https://www.youtube.com/watch?v=_3loq22TxSc&t=2705s) Slide Zoom Loops and Visual Recursion
Wildenhain explores the "Zoom" feature (specifically Slide Zoom and Summary Zoom), which lets users drag entire slides onto another slide canvas to embed live, interactive preview thumbnails. Because these embedded slide thumbnails dynamically reflect the contents of the target slides, he tests what happens when a slide contains a thumbnail link referencing itself or forming a cyclic dependency loop between slides.
```mermaid flowchart LR accTitle: Slide Zoom Dependency Loop accDescr: Circular dependency created by embedding slide thumbnails inside one another to test recursion. S1["Slide 1 (Summary Canvas)"] -->|"Embeds thumbnail of"| S2["Slide 2 (Target Slide)"] S2 -->|"Embeds thumbnail of"| S1 ```
He observes the instinct of an engineer anticipating edge cases: “The first thing you think to yourself, which is like if you're a software developer who has to make this thing, you're like, okay, but what about cyclic dependencies, right? We don't want cyclic dependencies.” PowerPoint guards against execution crashes by rendering static preview snapshots rather than recalculating an infinite visual recursion loop at runtime. Combining these nested slide zoom objects enables retro recursive visual corridors, though Wildenhain points out an aesthetic hurdle: embedded slide previews default to rendering with an opaque white slide background, setting up the need to isolate or strip slide backdrops.
[46:52](https://www.youtube.com/watch?v=_3loq22TxSc&t=2812s) Slide Zoom Fractals and Recursive Thumbnail Propagation
Tom Wildenhain demonstrates how PowerPoint's built-in slide zoom feature can be exploited to generate complex fractal patterns directly on a slide. When a slide thumbnail is embedded inside itself or linked across slides, PowerPoint recursively updates the preview images, though the software enforces an internal limit on how many recursive passes it will execute before stopping. To force PowerPoint to re-render deeper iterations, a user must actively trigger an edit to prompt the thumbnail pipeline to redraw. Tom observes how the application tries to manage the visual transition during presentation mode: “And it decides to retain a copy of the slide that you came from as the background just to make it look more in fact I guess you know those with our fractals.” Because the thumbnail was configured with a transparent background, PowerPoint preserves visual artifacts around the perimeter from the originating slide, creating layered borders as the zoom animation dives inward.
```mermaid flowchart TD accTitle: PowerPoint Recursive Slide Zoom Flow accDescr: Cycle of slide thumbnails re-rendering nested previews until hitting recursion limits.
subgraph RenderLoop ["Thumbnail Recursion Loop"] A["Slide with Thumbnail"] -->|"Point to self or partner slide"| B["PowerPoint Renders Preview"] B -->|"Nested preview update"| C["Recursive Thumbnail Propagation"] C -->|"Internal limit reached"| D["Halt Re-rendering"] D -.->|"Manual slide edit"| B end D --> E["Interactive Zoom Presentation"] ```
- When clicking on an active thumbnail during a slideshow, PowerPoint executes a smooth zoom animation into the target slide. - Setting slide thumbnails to transparent causes PowerPoint to retain visual elements of the parent slide behind the thumbnail border, creating overlapping visual artifacts.
[48:20](https://www.youtube.com/watch?v=_3loq22TxSc&t=2900s) Dragon Fractals and 2.5D Shading Tricks
Moving beyond simple triangular recursions, Tom shows how to construct a dragon fractal using only two slide thumbnails positioned with specific geometric transformations. By dropping a simple blue square into the composition and letting the zoom thumbnails repeatedly replicate and rotate, the nested images converge toward the fractal's fixed points. Although the geometry remains strictly two-dimensional, Tom explains that the visual appearance gains perceived depth through styling tricks: “This is just a 2D fractal still, it's just that by placing the objects offset it's gonna look like a step to it.” By applying built-in glow effects and subtle spatial offsets across the thumbnail boundaries, the flat self-similar pattern takes on the appearance of an illuminated, stepped 3D relief before the effect is stripped away to show the raw shapes underneath.
- A dragon fractal is produced using as few as two linked thumbnail objects that continually replicate and map onto each other's visual space. - Subtle drop shadows, glow effects, and spatial offsets make flat vector shapes appear layered like a three-dimensional staircase.
[49:40](https://www.youtube.com/watch?v=_3loq22TxSc&t=2980s) PowerPoint Designer and AI Slide Layouts
To wrap up the lecture, Tom pivots from esoteric programming hacks to an official, production feature added to modern PowerPoint: PowerPoint Designer. He jokes that learning about an intended presentation utility might be anticlimactic compared to turning slides into a Turing machine: “Now this is actually used for making presentations, so you'll find it nearly as interesting as these other features.” He demonstrates typing unstructured bullet points onto a blank canvas—such as typing words like fire or microwave—and shows how PowerPoint dynamically parses the text and suggests professionally styled layouts. Tom remarks on its ability to automatically map text concepts to relevant iconography: “It doesn't actually figure it out, like on 'fire' microwave, the concept of bullet points, which I was pretty impressed by, and will give you suggestions actually.” The lecture concludes with the audience laughing and applauding the full range of unintended computation and practical quirks uncovered inside the presentation software.
## Notable quotes > [00:06](https://www.youtube.com/watch?v=_3loq22TxSc&t=6s) And whenever you have a lot of features, they can interact with each other in different ways, and that gives you a lot of edge cases, and those edge cases often have very interesting behaviors in PowerPoint. — Tom Wildenhain
## Mentioned Tom Wildenhain, Carnegie Mellon University, Microsoft PowerPoint, Microsoft Excel, Microsoft Paint, Notepad, Windows XP, Vim, Portal, Python, Adobe Illustrator, Office 365
## Video description Recording of a guest lecture I gave for the Esoteric Programming Languages course at CMU.
Original PowerPoint Turing Machine video: https://youtu.be/sdkxWqsk17c
PowerPoint CPU: https://devpost.com/software/ppcc
[Source](https://www.youtube.com/watch?v=_3loq22TxSc)