PICO-8 Maker Imposes Engine Limits to Cure Developer Decision Fatigue
NYU Game Center
Arbitrary technical constraints foster creative freedom by eliminating logistical paralysis and giving developers guilt-free license to abandon bloated projects by shifting the blame onto the platform.
AI-assisted summary of PRACTICE 2018: Joseph White — original source. Check the original for full context.
Source published:
Key ideas
- Fantasy consoles like PICO-8 operate as 'impressionist hardware,' prioritizing emotional resonance, nostalgia, and psychological comfort over authentic silicon CPU emulation. (34:00)
- PICO-8 establishes a 'cozy design space' by taking on major logistical decisions—enforcing a 128x128 resolution, a fixed 16-color palette, and a 32 KB cartridge limit to eliminate decision fatigue and software friction. (40:36)
- Strict technical limitations act as an emotional safety valve for creators, providing guilt-free permission to abandon projects once token or memory budgets run out by shifting the blame onto the platform's designer. (42:38)
- While open-source reimplementations aid long-term software preservation, PICO-8's official core remains closed-source to prevent community fragmentation and protect its shared cultural baseline. (57:11)
Detailed notes
## Background Published on YouTube by NYU Game Center on August 7, 2018, this video documents Joseph White's talk 'PICO-8 and the Search for Cosy Design Spaces' recorded at PRACTICE 2018. According to the event description, the presentation examines how creative tools can actively guide ideas and operate as design manifestos, using the development history and community culture of the fantasy console PICO-8 as a primary case study.
## TL;DR Joseph White details the philosophy behind PICO-8, framing fantasy consoles as impressionist virtual platforms engineered to evoke specific feelings rather than strictly emulate legacy retro hardware. By locking down rigid technical constraints—including a 128x128 square resolution, a custom 16-color palette, and strict code token limits—PICO-8 intentionally eliminates decision fatigue and commercial pressure to foster a 'cozy design space.' White explains that a tool's architecture serves as an implicit design manifesto, showing how features like steganographic PNG cartridges, integrated editors, and memory-poking encourage remixing, playfulness, and guilt-free project abandonment. The talk concludes by highlighting how meta-designing boundaries transforms tedious technical friction into bite-sized creative challenges.
## Atmosphere & style The presentation has a warm, intimate, and gently eccentric atmosphere, emphasized by White delivering his entire slide deck inside PICO-8 using its idiosyncratic, ultra-compact pixel font. His delivery is soft-spoken, self-effacing, and reflective, punctuated by dry humor and candid personal admissions about everything from interface-induced 'software rage' to the visceral stress caused by modern startup sounds. Listening to the talk feels like sitting beside a thoughtful craftsman in a quiet workshop, discovering how deliberate digital friction can rekindle the pure, childlike joy of making things.
## Bulletin - [34:00](https://www.youtube.com/watch?v=87jfTIWosBw&t=2040s) Fantasy consoles like PICO-8 operate as 'impressionist hardware,' prioritizing emotional resonance, nostalgia, and psychological comfort over authentic silicon CPU emulation. - [40:36](https://www.youtube.com/watch?v=87jfTIWosBw&t=2436s) PICO-8 establishes a 'cozy design space' by taking on major logistical decisions—enforcing a 128x128 resolution, a fixed 16-color palette, and a 32 KB cartridge limit to eliminate decision fatigue and software friction. - [42:38](https://www.youtube.com/watch?v=87jfTIWosBw&t=2558s) Strict technical limitations act as an emotional safety valve for creators, providing guilt-free permission to abandon projects once token or memory budgets run out by shifting the blame onto the platform's designer. - [57:11](https://www.youtube.com/watch?v=87jfTIWosBw&t=3431s) While open-source reimplementations aid long-term software preservation, PICO-8's official core remains closed-source to prevent community fragmentation and protect its shared cultural baseline.
## Key takeaways - [04:03](https://www.youtube.com/watch?v=87jfTIWosBw&t=243s) A fantasy console is defined more by its community, distribution channels, and shared cultural constraints than by physical hardware. - [15:04](https://www.youtube.com/watch?v=87jfTIWosBw&t=904s) Self-contained development tools eliminate external software friction and the cognitive clutter of modern cross-platform deployment. - [18:52](https://www.youtube.com/watch?v=87jfTIWosBw&t=1132s) The virtual cartridge concept was introduced to give creators independent authorship over standalone games rather than feeling like subordinate level editors. - [24:15](https://www.youtube.com/watch?v=87jfTIWosBw&t=1455s) PICO-8's 16-color palette was engineered through annealing and folding, forcing single tones like dark blue to multitask as shadows, skies, and accents. - [27:35](https://www.youtube.com/watch?v=87jfTIWosBw&t=1655s) The API intentionally omits built-in collision and complex sorting routines, encouraging developers to solve lightweight, satisfying 'cute problems' from first principles. - [29:14](https://www.youtube.com/watch?v=87jfTIWosBw&t=1754s) Code capacity limits were transitioned from character counts to tokens to prevent counterproductive minification and keep community code human-readable. - [31:17](https://www.youtube.com/watch?v=87jfTIWosBw&t=1877s) The dedicated boot sequence and audio chime serve as a psychological boundary, transitioning creators away from OS stress into an isolated virtual workspace. - [35:47](https://www.youtube.com/watch?v=87jfTIWosBw&t=2147s) Instead of treating save data corruption as a software bug, the community embraced it as authentic hardware behavior and built redundant voting logic. - [37:09](https://www.youtube.com/watch?v=87jfTIWosBw&t=2229s) Tools inherently act as implicit design manifestos by setting defaults that invite specific creative behaviors without requiring written dogma. - [39:00](https://www.youtube.com/watch?v=87jfTIWosBw&t=2340s) When stuck in a design rat hole, stepping up into meta-design allows creators to solve issues by reshaping boundary constraints rather than forcing content solutions. - [40:36](https://www.youtube.com/watch?v=87jfTIWosBw&t=2436s) Cozy design spaces eliminate ego and fear of failure, allowing developers to create small, disposable projects purely for the joy of making. - [54:58](https://www.youtube.com/watch?v=87jfTIWosBw&t=3298s) The engine remains an inadvertent self-portrait of its author, balancing user artistic autonomy against the personal aesthetics baked into the environment. - [57:11](https://www.youtube.com/watch?v=87jfTIWosBw&t=3431s) PICO-8's core remains closed-source during active development to preserve the integrity of its common baseline against platform divergence.
## Detailed walkthrough ### [00:07](https://www.youtube.com/watch?v=87jfTIWosBw&t=7s) Introducing Joseph White and the Fantasy Console Concept
An NYU host opens the talk by introducing Joseph White, widely known by his handle "zep." The host characterizes White as one of the longest-standing indie game developers around, noting that his first commercial title debuted in 1993 as shareware distributed across dial-up bulletin board systems (BBSs). Around 2007, White gained wider indie prominence under his Lexaloffle Games banner by releasing well-received puzzle titles such as *Zen Puzzle Garden* and *Chocolate Castle*. Today, however, White is speaking as the inventor and pioneer of the "fantasy console"—a concept gathering momentum across independent game development and education.
The host defines a fantasy console as a videogame hardware platform that exists exclusively as an emulation layer and a deliberate set of virtual hardware specifications. Addressing why someone would seek out an intentionally constrained environment, the host argues that the format fundamentally clarifies the creative process:
> “I think for me I would kind of encapsulate it as it simplifies and scopes down game development in a way that just makes it more enjoyable...”
To illustrate that impact, the host recounts teaching a semester-long class where students developed their projects exclusively within PICO-8. After grades were submitted, the host saw an end-of-semester tweet from one student that captured the platform's core appeal:
> “...we've been using exclusively PICO-8 in my class this semester and in my last few months at college I finally understand why game—why game development is fun...”
[02:04](https://www.youtube.com/watch?v=87jfTIWosBw&t=124s) Defining the Concept and Setting Up the Talk
Taking the podium, Joseph White admits he is grateful for the host's clear intro because he still dislikes trying to explain what a fantasy console is himself. The concept grew out of two motivations: observing how expressive, scoped development environments like Anna Anthropy's PuzzleScript and Twine established strong identities that showed through directly in the games created with them, and needing a clear vocabulary to explain his own idiosyncratic design goals to his users.
White explains the visual layout of his presentation slides, which he runs natively inside PICO-8. He uses a color-coding scheme to orient the audience through different registers of the talk: - **Warm colors**: Practical, familiar topics describing the concrete mechanics of PICO-8 and how the engine came to be. - **Cold colors**: Text-heavy, theoretical musings exploring the broader philosophical nature of tools, the fantasy console concept, and its implications for creators.
Ultimately, White intends to reconcile the theory and practice around PICO-8's guiding creative goal: cultivating a "cozy" design space. Before diving into the technical breakdown, White takes an audience poll to see how many people have used PICO-8, specifically asking attendees to keep their hands raised only if they have finished and released a cartridge, thanking them directly for putting work into the ecosystem.
[04:03](https://www.youtube.com/watch?v=87jfTIWosBw&t=243s) Virtual Hardware Constraints and the Built-in Suite
White stresses that what truly defines a videogame console is not physical hardware silicon, but rather the ecosystem surrounding it: the culture, community, shared conventions, and distribution methods. Because PICO-8 must artificially simulate those conditions, its technical specifications were chosen with extreme care to give the engine its distinctive personality.
```mermaid flowchart LR accTitle: PICO-8 Built-in Development Pipeline accDescr: A linear flowchart illustrating the built-in PICO-8 workflow from text prompt to code, visuals, audio, and exported PNG cartridge.
subgraph CoreEngine["Engine & CLI"] CLI["Command Line Prompt<br/>(Reboot / Lua Execution)"] end
subgraph Editors["Integrated Toolset"] Code["Code Editor<br/>(128x128 Micro-Font)"] Sprite["Sprite Editor<br/>(128x128 Pixel Sheet)"] Map["Map Editor<br/>(8-bit Grid Data)"] Audio["SFX / Tracker<br/>(4 Ch Sync Synth)"] end
subgraph Export["Distribution"] Cart["Cartridge Export<br/>(RGBA Steganography PNG)"] end
CLI --> Code Code <--> Sprite Sprite <--> Map Map <--> Audio Audio --> Cart ```
White walks through the core constraints that define the environment: - **Resolution**: Scaled to the absolute smallest dimensions viable (128×128 pixels) while still offering enough visual clarity to construct nearly any genre of game. - **Palette**: A fixed 16-color palette, designed obsessively to function as an aesthetic microcosm of the platform's overall design constraints. - **Cartridge Size**: Capped strictly at 32 kilobytes, prioritizing rapid design iteration and concept capture over raw asset volume: “I want people to just make something, capture the concept, and then just move on to something else and to feel okay to do that.” - **Sound**: A four-channel, synthesizer-based audio toolset reduced to its absolute fundamentals. - **Integrated Environment**: All development tools (code editor, sprite canvas, tilemap editor, sound synthesizer, and tracker) reside entirely inside the engine itself.
[05:33](https://www.youtube.com/watch?v=87jfTIWosBw&t=333s) Live Coding, Trackers, and the Ritual of CLS
Hitting the Escape key, White drops straight from his running slide deck into the native PICO-8 command-line interface to demonstrate live development. He highlights the interactive Lua prompt, draws a fast "standard test bunny" sprite in the pixel editor, and sketches a screen in the tilemap editor. The map data is intentionally stripped of semantic engine assumptions: it is simply an open matrix of 8-bit memory cells whose meanings are decided entirely by the author.
He toggles to the audio editor, showing that sound effects and music share identical foundational data, with music effectively acting as slowly sequenced sound patterns. Switching into the Amiga-style tracker view, he layers polyphonic voices across channels to produce an instant chiptune loop, joking to the audience, “Okay, we can ship it, right?”
Moving to the built-in code editor, White addresses the engine's polarizing, ultra-compact 128×128 pixel font:
> “About half of the users do everything in this horrible font, and I wanted to make you suffer today by reading this font for this presentation so you can feel what it's like for a PICO-8 user...”
White writes an update and draw loop in Lua from scratch, opening with a clear-screen command and reflecting on its emotional resonance:
> “I love CLS—as soon as I type CLS, I feel good... when you're starting a new program, when you type CLS you're not just clearing the screen, you're clearing your mind and your soul, preparing for something new.”
He finishes the demo script by calculating sine-wave offsets to animate the bunny sprite bouncing across the screen and prints text with embedded control glyphs.
[09:54](https://www.youtube.com/watch?v=87jfTIWosBw&t=594s) Steganographic Cartridges and the Reality of Memory Glitches
Wrapping up the quick demo, White demonstrates how PICO-8 cartridges are exported and shared. The entire project—source code, map arrays, sprites, and audio patterns—is encoded steganographically into the lower bits of the red, green, blue, and alpha color channels of an ordinary `.png` image. By zooming into the exported label image, White shows the subtle, noisy fuzz of the payload pixels. Anyone who downloads that image file can drag it into their local PICO-8 shell, immediately run it, or press Escape to open the hood, inspect the raw Lua source, and tweak the assets.
White then loads *Jumpy*, a simple platformer cart he published during PICO-8's first alpha release three years earlier. At the top of the unedited script sits a visible, unfinished to-do note reading `TODO: levels and monsters`. White intentionally left that artifact intact across thousands of player downloads:
> “That turned out to be a good thing to do, because it sort of like showed by example it's okay just to release stuff, it's fine, you know, you're—you're among friends.”
To expose the raw materials of the virtual architecture, White activates an in-engine corruption mode using native `poke()` operations: - **Pixel Mapping**: One memory byte corresponds directly to two horizontally adjacent 4-bit screen pixels. - **Live Memory Corruption**: Injecting random values across memory addresses every frame dynamically warps the visual tiles, scrambles sound filter frequencies, and flips binary bit flags (turning map decorations into live enemy entities on the fly). - **Crash Prevention**: Even under violent memory trash, the virtual machine never hard crashes because the active Lua engine and execution bytecode are quarantined inside a separate, protected memory allocation.
White concludes that glitches are crucial for grounding an abstract software system:
> “When you see glitches in games or anything, it sort of shows the underlying material of the system, and one thing like the first thing I did as soon as everything was running in PICO-8 was: okay, I need to corrupt this and see if it glitches nicely.”
He ends the segment by previewing the cart explorer (`SPLORE`), flipping through experimental community creations that range from talking procedural cats and hugging simulators to projects designed specifically to stress-test the machine beyond its intended limits.
[14:01](https://www.youtube.com/watch?v=87jfTIWosBw&t=841s) Drawing Spiderwebs and Returning to the Slides
Joseph White continues demonstrating a project on PICO-8, emphasizing the physical feel of digital drawing. He observes that in traditional art, the essence lies in nuance and precision, noting that “the point of calligraphy is is the the touch and the nuance.” In his interactive sketch, control is deliberately imperfect: operating with an eight-directional digital pad, he added inertia to the brush, resulting in a playful tension where things naturally go wrong. He explains that it is essentially a game centered on drawing and weaving spiderwebs. While it technically includes traditional mechanics like goals, scores, and action, White admits he prefers to simply relax and take the time to construct web strands across the screen. Concluding the live demonstration, he switches back to his presentation slides to examine the origins of the console.
[15:04](https://www.youtube.com/watch?v=87jfTIWosBw&t=904s) Creative Motivations and the Plague of "Software Rage"
Reflecting on the creation of PICO-8, White describes it as an exceptionally enjoyable endeavor because an intricate mix of practical considerations, aesthetic ambitions, and creative impulses naturally pushed it forward. He notes that with certain projects, once the foundational problem and goals are set, the momentum carries you straight through to the finish. White’s love for writing creative software began in childhood, when he constantly coded pixel-art drawing tools purely for the joy of it. With PICO-8, his primary goal was to construct an environment that allowed him to work on his own terms rather than constantly fighting against hostile commercial software. He wanted to strip away mental clutter regarding target platforms and deployment, settling instead on a self-contained aesthetic world where games could exist purely in an abstract space.
```mermaid flowchart LR accTitle: Creative Friction vs PICO-8 Design accDescr: Modern tool friction and delay leading to rage compared to PICO-8's focused environment. subgraph Modern["Modern Workflows"] A["Clicking UI Elements"] --> B["Half-Second Latency"] B --> C["Lizard-Brain Rage & Interruption"] end subgraph Solution["PICO-8 Philosophy"] D["Abstract House Style"] --> E["Zero Platform Overhead"] E --> F["Immediate Creative Flow"] end ```
White vents his deep exasperation with the modern software landscape, bluntly declaring, “software sucks it's terrible.” While he considers himself an exceptionally calm person who has never experienced road rage, he suffers severely from what he calls "software rage." He describes how even a mere half-second delay between clicking an icon and a window appearing sends his mind into an animalistic fury:
> “I don't get road rage I have no idea what that feels like but I have software rage like the the time between doing clicking on something and waiting for half second for a window to pop up that half a second my mind is completely lizard brain raging animal and I feel as it's much more disruptive to a creative work then then we generally realized...”
[16:50](https://www.youtube.com/watch?v=87jfTIWosBw&t=1010s) Napkins, the Demoscene, and "Cute Problems"
To guide the design of PICO-8, White looked backward to specific tactile and emotional experiences he wished to recreate: - **Rummaging through mystery disks:** Digging through unorganized boxes of Commodore 64 and Amiga floppy disks, where running an unlabeled program offered the thrill of discovery because you had no advance knowledge of what was on the disk. - **The disposable napkin effect:** Realizing that his best creative thinking occurred on restaurant paper napkins precisely because they were destined for the trash. He deliberately worked on napkins to access that relaxed, low-stakes mindset, eventually accumulating piles of crumpled napkins in his bag. - **The demoscene spirit:** Growing up isolated in New Zealand, White viewed demoscene productions not as commercial products, but as heartfelt digital letters shared between coders. Because these non-commercial demos were made simply for the love of the craft, watching them generated an intimate sense of personal connection to their creators.
White also draws a sharp distinction between "cute problems" and "annoying problems." He feels genuine relief when tasked with implementing a concrete algorithmic challenge, such as writing a collision system from scratch, saying, “thank goodness I can do some computer science.” By contrast, he laments that contemporary programming largely consists of engineering tedious "glue" to force disparate software frameworks to cooperate. PICO-8 was built to dispense with that glue code, offering a gentle, pressure-free environment designed for play.
[18:52](https://www.youtube.com/watch?v=87jfTIWosBw&t=1132s) Voxatron and the Origin of Fantasy Cartridges
White traces the conceptual origins of the fantasy console back to his earlier project, Voxatron, which he initially released in 2011. Voxatron was designed around a 3D volumetric display consisting of a cube of voxels, making it suited for destructible physics environments. White demonstrates this by loading a 3D voxel remake of his game *Jasper's Journeys* (which he jokingly references as the "hug game" from his earlier slide, *Suspension and Souls*), rotating the volumetric view to showcase its depth.
When Voxatron first launched, the unifying metaphor of the "fantasy console" did not yet exist. White had framed the software monolithically, offering built-in "game modes" alongside an integrated "level designer." However, this terminology created a severe authorship dilemma:
> “The problem is that it's monolithic and I didn't know how to present work made in it as as something that felt like his you know separate creation and I wanted people to feel that they were the authors of this thing they weren't just making a level for another platform...”
To give creators true ownership over their work, White conceived of "cartridges" as a shareable, atomic unit of creative expression. Even after adopting cartridges in Voxatron and beginning work on PICO-8, it took him years to realize that Voxatron itself should be classified and packaged as an equivalent fantasy console. He notes that the next major update will allow Voxatron to emerge from its cocoon as a fully realized fantasy system.
[21:16](https://www.youtube.com/watch?v=87jfTIWosBw&t=1276s) Designing a Cohesive Fantasy Console Medium
White emphasizes that PICO-8 is designed to be completely self-contained, with its own unified identity, ecosystem, and distribution methods, such as exporting programs into digital cartridge files. Unlike software emulators, PICO-8 does not attempt to reproduce historical hardware like the BBC Micro or the Commodore 64. Those retro platforms had rigid specifications dictated by the physical chip manufacturing limits of their respective decades; PICO-8, by contrast, is an intentional, contemporary design created entirely from scratch.
White follows several core design principles to make PICO-8 behave like an artistic medium rather than an open-ended software engine: - **Paternalistic constraint:** Deciding arbitrary limits on behalf of the creator, ensuring that users cannot make visually disharmonious work. He compares this to a curated box of crayons where every color combination works naturally together. - **Balanced internal specifications:** Ensuring memory, sound, display resolution, and code capacity interact harmoniously. Providing immense graphical capabilities without sufficient code space to drive them produces a frustrating, unbalanced platform. - **Strategic friction:** Injecting friction into specific areas of the toolchain to steer users toward compelling, bite-sized creative challenges while shielding them from uninteresting technical boilerplate. - **Medium-like material qualities:** Bestowing the software with innate texture and behavioral weight, analogous to how paint interacts with the woven tooth of a canvas.
Addressing specific hardware choices, White explains that the 128x128 display is intentionally square. This eliminates the developer's dilemma over choosing between horizontal and vertical screen orientations. Although users frequently lobby for a widescreen aspect ratio suited to modern PC monitors, White intentionally retained the square format because its eccentricity signals to users that they are stepping into an entirely separate, distinct realm. Architecturally, the display connects directly to his 3D work: the volumetric display of Voxatron is literally composed of 64 PICO-8 screens stacked vertically.
[24:15](https://www.youtube.com/watch?v=87jfTIWosBw&t=1455s) The 16-Color Palette: Annealing and Folding
White considers the creation of PICO-8’s iconic 16-color palette to be a microcosm of how the entire console was engineered. Its balance was found through two interrelated design processes:
```mermaid flowchart TD accTitle: Palette Design Mechanics accDescr: Annealing and Folding processes shaping the 16-color PICO-8 palette. subgraph Annealing["Simulated Annealing"] A1["High Temperature: Wild Placeholder Swaps"] --> A2["Gradual Cooling & Interaction Tests"] A2 --> A3["Low Temperature: Subtle Micro-Adjustments"] end subgraph Folding["Gravitational Folding"] B1["8-Color Top Rainbow Ramp"] --> B4["Interlocking Blue Values"] B2["Dedicated Grayscale Ramp"] --> B4 B3["Cold Tones Leading into Warm Light"] --> B4 end Annealing -.-> B4 ```
1. **Annealing:** Borrowed from computer science and metallurgy, this approach begins at a "high temperature," where hundreds of wildly differing placeholder ideas bounce around the design space. Over time, the temperature is steadily lowered, reducing variance until elements make only microscopic adjustments relative to one another. 2. **Folding:** A dynamic where multiple competing requirements generate internal gravity, warping and pulling components into multifaceted roles.
When designing the palette, White required a bright, eight-color looping rainbow across the top row to give creators instant access to vibrant color ramps. Simultaneously, he had to integrate a legible grayscale ramp and provide cool tones that transitioned smoothly into warm colors for natural outdoor lighting. Certain colors—most notably the dark blue—had to perform double duty across multiple palettes, serving simultaneously as a shadow tone, a midtone for sky, and an accent.
This complex balancing act reflected the console's wider development. Every constraint was intimately linked: expanding the sound effect footprint applied gravitational pressure against the available code storage limits, while introducing a single new API function altered the creative utility of every other command in the system.
[26:13](https://www.youtube.com/watch?v=87jfTIWosBw&t=1573s) The Freedom of Tiny Cartridges and Minimal Audio
Joseph White reflects on tracking his own development rhythm in his notes, observing how the rush of early progress inevitably slows down over time. Turning to the strict constraints of PICO-8, he explains that the cartridge size was deliberately capped so that developers simply cannot build sprawling, massive projects. Being restricted to small scopes creates a liberating environment where creators feel permission to make modest things. Instead of getting bogged down in manufacturing huge volumes of content, developers are forced to contemplate core design, isolate what truly matters to them, and discard unnecessary fluff. Tight constraints also push authors into confronting what White calls “cute problems”—such as figuring out how to squeeze data into tight spaces—which frequently open up unexpected, rewarding creative paths.
```mermaid flowchart TD accTitle: Constraint to Creative Path accDescr: Flowchart showing how small cartridge limits drive focus on core game design and cute technical puzzles. A["Strict Cartridge Limit"] --> B["Cannot make big things"] B --> C["Focus on core design over content manufacturing"] B --> D["Solve cute data-packing problems"] C --> E["Creative breakthrough"] D --> E ```
That same philosophy extends directly to sound design. The sound effects editor is pared down to the absolute bare minimum, making it almost impossible for users to make catastrophic mistakes. A developer can quickly doodle random waveform shapes, hold down the control key to snap the pitch grid to a pentatonic scale, and immediately produce charming music suitable for a title screen. As White emphasizes:
> “I think it's just really liberating to make small things enter be and to feel okay to make small things it make it forces you to think more about design then manufacturing a lot of content and and to focus on what's important to you in throw away things that are not important and it forces you to confront the cute problems like how to fit your data in and often you know those problems lead you down a new path that you wouldn't have otherwise considered.”
- **Cartridge Philosophy:** Hard data limits force creators to abandon content bloat in favor of intentional, essential design decisions. - **Audio Simplicity:** The built-in tracker/synthesizer allows drawing sound curves freely, with modifier shortcuts (like holding `Ctrl` for a pentatonic scale) ensuring musical results with zero music theory background.
---
[27:35](https://www.youtube.com/watch?v=87jfTIWosBw&t=1655s) A No-Magic API and the Joy of Hand-Rolled Code
When designing the PICO-8 application programming interface (API), White prioritized extreme minimalism, not merely for convenience, but to avoid introducing “magic” abstractions into the environment. There is no built-in collision routine and no high-level object handling; if a creator wants two sprites to interact, they must either code the math from scratch or paste an implementation from another cartridge. White believes this friction directly introduces newcomers to foundational computer science concepts, granting them the satisfaction of solving classic problems themselves.
To illustrate, he admits that while developing his own games, he temporarily implemented a native sorting function out of convenience, only to consciously remove it before release. For visual tasks like drawing rotating objects in pseudo-3D, a massive standard-library sorting algorithm is unnecessary anyway; a simple bubble sort routine pasted into the script works beautifully because the relative depth of rotating items barely changes from one frame to the next. He describes his exhaustion with sprawling modern APIs whose documentation is overwhelming to navigate, contrasting that fatigue with PICO-8’s philosophy:
> “So yeah I wanted an API that you can just hold in the palm of your hand and see the whole thing at once.”
- **No Black Boxes:** Omitting high-level collision and sorting routines demystifies programming and encourages learning from first principles or cartridge inspection. - **Micro-Algorithms:** A simple bubble sort is often optimal for spinning 3D wireframes/sprites because the elements remain almost sorted across consecutive frames. - **Single-Page Scale:** The complete PICO-8 API fits comfortably on a single cheat sheet or in the palm of a hand.
---
[29:14](https://www.youtube.com/watch?v=87jfTIWosBw&t=1754s) Three User-Driven Evolutions: Patterns, Tokens, and Multicarts
Once community cartridges began circulating, user behavior drove three major systemic adaptations in PICO-8's core architecture:
```mermaid flowchart LR accTitle: User-Driven PICO-8 Features accDescr: Three community behaviors leading to engine changes: dither patterns to fill patterns, minification to token limits, and cartridge limits to multicarts. subgraph Users ["User Behaviors"] U1["Manual 3D dithering"] U2["Aggressive code minification"] U3["Pushing past 32KB cartridge ceiling"] end subgraph Engine ["Engine Adaptations"] E1["Native 4x4 binary fill patterns"] E2["Token limit replaces ASCII char count"] E3["Multicarts export feature"] end U1 --> E1 U2 --> E2 U3 --> E3 ```
1. **Fill Patterns:** Users were writing custom dithering patterns to overcome the 16-color palette and simulate shaded 3D geometry. White loved the tactile, physical appearance of these textured surfaces at low resolution and added native fill patterns to reduce friction. This feature also serves an educational purpose: setting up a 4×4 pixel pattern requires developers to calculate powers of two across a 16-bit binary mask, serving as a friendly gateway to binary representation. 2. **From Characters to Tokens:** The original release limited source code by raw ASCII character count. This inadvertently incentivized programmers to minify their code—stripping whitespace and shortening variable names to single letters—which destroyed readable, shareable code. White redesigned the limit around a token counter, where an identifier, keyword, or operator counts as a single token regardless of length. This stopped minification and turned code golf into a playful economy: “it just feels cuter spending tokens.” 3. **Multicarts:** Creators constantly chafed against the 32 KB compressed cartridge boundary. Unwilling to sacrifice the sacredness of the cartridge limit, White implemented “multicarts,” allowing standalone executables to bundle multiple cartridges together and swap between them dynamically. Yet in practice, almost nobody actually used the multicart feature once it existed, prompting White to chuckle: “people don't know what they want.”
White summarizes the driving problem behind the initial character-count system:
> “The code was too small on the first release and so I and people were minifying their code that was a big problem it defeated the purpose of having shareable code so I changed the code size limit from s key characters to tokens you know so one word or one variable name is a token and that helped a lot to avoid minification and also it just feels cuter spending tokens.”
---
[31:17](https://www.youtube.com/watch?v=87jfTIWosBw&t=1877s) Framing the Boot Sequence and Reclaiming the Chime
White explains that the boot sequence is not just decorative flair; it establishes crucial psychological framing and presentation. Launching the program immerses the user in an alternate space where they feel truly “inside the machine.” The boot chime plays a vital role in resetting the creator's mental state, serving as a mnemonic call back to creative play.
This design choice was born directly out of personal trauma from past contract work. White recalls spending miserable periods doing development work inside environments like Xcode. Over time, classical Pavlovian conditioning turned his Mac's hardware startup chime into a visceral trigger: whenever he booted his Macintosh, he could physically feel the back of his head burning with dread. Designing the PICO-8 chime was a deliberate act of emotional reclamation, crafting a sonic ritual that triggers curiosity and calm focus rather than corporate fatigue. He reflects:
> “And every time I turned on my Macintosh and I heard that time I could feel the bank of my head burning like just from the chime just because of heavy on conditioning and so I'm trying to reclaim that I'm trying to wipe that.”
---
[32:22](https://www.youtube.com/watch?v=87jfTIWosBw&t=1942s) The Blue Zone: Impressionist Hardware and Conceptual Scaffolding
Entering what he calls the “Blue Zone” of his presentation, White introduces his definition of a fantasy console: it is fundamentally “impressionist hardware.” Rather than solving strict electronic engineering challenges, the designer crafts an aesthetic illusion focused entirely on evoking the psychological and nostalgic sensations of operating physical hardware. The designer must deliberately draw the line where literal simulation gives way to artistic metaphor. PICO-8 does not emulate an authentic CPU instruction set; it runs a standard Lua virtual machine, because a custom assembly instruction set was not necessary to achieve a tactile, authentic retro feel.
```mermaid flowchart TD accTitle: Fantasy Console Triangulation accDescr: Mapping PICO-8 and Voxatron alongside speculative scaffolding designs PICO-16 and PICO-64 to define design boundaries. subgraph Real ["Actual Consoles"] P8["PICO-8<br/>(2D / 128x128)"] VX["Voxatron<br/>(3D Voxel Arena)"] end subgraph Scaffolding ["Negative Scaffolding (Unmade)"] P16["PICO-16<br/>(What NOT to build)"] P64["PICO-64<br/>(Equidistant conceptual probe)"] end P8 <-->|"Defines design axis"| VX P16 -.->|"Negative boundary"| P8 P64 -.->|"Equidistant probe"| VX ```
Language plays a foundational role in shaping this illusion. Simply labeling a program a “cartridge” immediately reconfigures user expectations, imbuing digital code with tangible permanence and historical context. White stresses that fantasy consoles are defined not by rigid dogmas, but by a Wittgensteinian “family resemblance” of features shared with systems like PuzzleScript or game jam ecosystems.
To clearly understand what PICO-8 was, White needed a comparative frame of reference. Only after having both PICO-8 and Voxatron side by side could he trace the outline of the medium. To test those boundaries further, he constructed hypothetical “scaffolding” consoles that he had no intention of releasing: - **PICO-16:** Designed as an explicit negative guidepost to illustrate design choices that felt bloated and broken, reminding him what *not* to build. - **PICO-64:** A thought experiment to determine what a fantasy console placed at an equal conceptual distance from both PICO-8 and Voxatron would look like.
White captures the essence of this design philosophy:
> “Fantasy consoles are basically impressionist hardware when you're designing one you're not thinking about how to solve engineering problems you're thinking about the feeling of the person using the console and and how to provoke all of those associations and emotions and it's really just a knife holder if something is a console of feels like a console you have to choose when it starts not being real.”
---
[35:47](https://www.youtube.com/watch?v=87jfTIWosBw&t=2147s) The Glitch Economy: Framing and Accidental Memory Corruption
Because PICO-8 presents itself as an idiosyncratic fantasy machine rather than a professional software suite, incoming developers arrive with clean expectations: “all bets are off,” giving White unprecedented freedom to experiment and fail. This unique framing was demonstrated when White introduced a reboot effect that injected random byte noise into memory upon resetting a cartridge to create an authentic visual glitch.
He inadvertently forgot that permanent saved data was mapped directly into that same memory region. As a consequence, resetting a cartridge routinely clobbered persistent user data. In standard software, corrupting save files would be met with outrage; in PICO-8, players assumed the glitch was an intentional, playful puzzle mechanic. Developers embraced it as an authentic hardware quirk and began engineering voting logic algorithms across redundant memory sectors to safeguard their data. While White eventually patched the bug, the episode highlighted how framing transforms software flaws into charming, atmospheric hardware traits. White notes:
> “So Pico eight is different enough from things that people have used in the past both as a player and a developer that when you see a boot you don't really expect anything of it and all bets are off and so I can kind of get away with anything.”
- **Glitch Injection:** Random values were intentionally pushed into RAM during reboots to simulate visual screen tearing and memory corruption. - **Save Corruption:** Permanent storage addresses overlapped the randomized memory range, resulting in corrupted persistent player records. - **Community Reaction:** Instead of complaining about broken software, the community treated the bug like quirky hardware behavior and devised mathematical fault-tolerant voting systems to store data reliably.
---
[37:09](https://www.youtube.com/watch?v=87jfTIWosBw&t=2229s) Tools as Implicit Manifestos
In his concluding thoughts for this segment, White explores the porous boundaries separating the tools we build, the media we produce, and the creative processes we follow. Every creator must construct or adopt a space of possibilities—whether by embracing Disney’s 12 basic principles of animation or targeting a specific console format. While tool, medium, and process can be treated as conceptually distinct, they are deeply coupled: altering one reshapes the others.
White points out that a designer does not need to publish a written ideological manifesto. When built with strong convictions, a tool embodies that manifesto within its very constraints and defaults, naturally encouraging practices that harmonize with those values while discouraging discordant workflows. A well-crafted tool goes beyond functional utility; its specific constraints act as an open invitation, sparking an immediate desire to create something within its idiosyncratic world. White explains:
> “So just by just by using a tool that you don't you don't need to state a manifesto the the tool sometimes has the manifesto inside itself because it lets you do things which are congruent with with that set of design values.”
[39:00](https://www.youtube.com/watch?v=87jfTIWosBw&t=2340s) Meta-Design and Shaping Creative Possibility Spaces
Joseph White reflects on how creative tools interact with the creative process. Much like a traditional watchmaker must handcraft specialized tools before assembling a watch, building tools is an unavoidable, entangled step in design. The medium shapes the tools, and the tools reach directly into both the development workflow and the final artifact, resulting in a single “very big fuzzy blob.”
When game designers find themselves trapped in a creative quagmire or design rat hole, the only reliable escape route is to pop up one frame on their mental stack and engage in meta-design to examine the boundaries they are operating within. Instead of attempting to design the final object outright, a developer can design the surrounding constraints. By intentionally engineering these boundaries, the designer creates a possibility space fertile enough that anyone operating inside it cannot help but stumble into captivating creative solutions.
“When you're a designer and you get into a design rat hole, into a quagmire, the only way to get out is to pop up one frame of your stack and sort of do meta-design and see what are the boundaries that you're operating inside.” — Joseph White
[40:36](https://www.youtube.com/watch?v=87jfTIWosBw&t=2436s) Cozy Design Spaces, Cuteness, and Banishing Decision Fatigue
Bringing these ideas back to PICO-8, White summarizes its core design objective as offering a “cozy” design space. He connects this feeling to cuteness—a quality that machines and software environments can possess when they are small, inviting, and somewhat vulnerable. Rather than feeling limiting, this compact scale paradoxically fosters a deep sense of psychological safety and artistic freedom. Within a cozy space, developers do not worry about doing things wrong or impressing peers; they leave their egos at the door and create purely for the joy of making, playfully casting their creations out into the world like messages in a bottle.
Above all, a cozy design space wages war on decision fatigue. Large-scale software projects overwhelm creators with paralyzing logistical questions: How large should the game be? What is the monetization model? How will it be distributed? How will it physically exist? PICO-8 sweeps all of that existential friction away by shouldering the architectural burden on behalf of the creator.
“In a cozy design space you don't feel afraid to do anything wrong, you can leave your ego behind and not try to be impressing anybody or anything like this, you just want to make something for the love of making.” — Joseph White
- **Decisions eliminated by PICO-8:** Screen resolution, display palette, distribution pipeline, file formatting, asset packaging, and runtime environment. - **Creator mindset:** Users are freed from logistical worry through a simple design contract: “I'll take care of that, just make a PICO-8 cart.”
```mermaid flowchart TD accTitle: Creative Design Spaces Comparison accDescr: Diagram contrasting unconstrained boundless design spaces that induce decision fatigue with cozy bounded spaces like PICO-8 that foster rapid exploration.
subgraph Unbounded ["Boundless Possibility Space"] U1["Infinite Design Decisions"] --> U2["Decision Fatigue & Sparseness"] U2 --> U3["Distant Points of Light: Abstract & Paralyzing"] end
subgraph Cozy ["Cozy Bounded Space (PICO-8)"] C1["Hard Limits: Code, Colors, Audio"] --> C2["Eliminated Logistical Overhead"] C2 --> C3["Lush Planet Surface: Playful, Low-Ego Exploration"] end ```
[42:38](https://www.youtube.com/watch?v=87jfTIWosBw&t=2558s) The Jungle Planet: Freedom Through Constraint and Permission to Abandon
Operating within clear boundaries produces an apparent paradox: constraints expand practical creative freedom. White contrasts this with an infinite, boundaryless creative void. Without constraints, a creative space is so sparse that it resembles floating in deep space—celestial bodies may be intricate and massive, but from afar they register only as cold, distant pinpricks of light. Imposing tight boundaries is like landing directly on the surface of a single, vibrant planet teeming with lush jungles and dense alien wildlife.
Having tangible boundaries also gives creators a clear baseline against which they can deliberately rebel, producing clever hacks and demoscene-style work that technically shouldn't fit within the machine. Furthermore, small constraints give developers emotional permission to abandon projects guilt-free. When a cart runs out of memory or tokens, developers are forced to move on, redirecting any guilt away from themselves and onto the platform creator.
“Being in a cute space gives you license to abandon things and just move on to the next thing, because you need more space and you have to do—there's no choice—and so you can blame that on me, the creator of the space.” — Joseph White
[44:33](https://www.youtube.com/watch?v=87jfTIWosBw&t=2673s) The Implicit Design Manifesto of PICO-8
PICO-8 fuses the journey of the toolmaker with the journey of the user into an implicit design manifesto embedded directly within the software's architecture. The central tenet of this philosophy is that small things have profound, standalone value. Modest creative artifacts are meaningful in their own right, and they serve as bite-sized modular components that can be easily remixed, inspected, and shared by others.
Rather than forcing creators to pioneer exhausting new paradigms from scratch, cozy tools encourage users to submit to the natural physics of the environment, letting themselves be gently carried along by the platform's idiosyncrasies while shutting out real-world pressures. White wraps up his presentation by crystallizing his five underlying points into a single realization: building a cozy space is ultimately about creating a safe, comfortable room to work in.
“The principles are that small things matter: you can make small things, they're valuable by themselves or as components for other things that can be remixed.” — Joseph White
- **Core tenets of the cozy design space manifesto:** 1. Small things have intrinsic, isolated value. 2. Artifacts can serve as remixable building blocks for others. 3. It is healthy to finish or abandon a small idea and cleanly move on. 4. Work joyfully inside defined, discoverable boundaries. 5. Allow yourself to be carried along by the space and ignore real-world noise.
[46:03](https://www.youtube.com/watch?v=87jfTIWosBw&t=2763s) Q&A: Joining the Party at 1.0 and Re-converging with Voxatron
The presentation transitions to audience questions. When asked about his immediate future plans, White jokes about his longing to finally step away from the software engine room. He likens his role as tool creator to being trapped alone in the kitchen preparing party snacks while hearing all the guests in the next room laughing, chatting, and drinking. His immediate goal for PICO-8’s eventual 1.0 release is to finish the core toolset so he can finally join the party, sit down, and make games as a regular user.
An audience member asks how PICO-8’s evolution will feed back into White's original voxel project, Voxatron. White explains that while Voxatron originally spawned PICO-8, the relationship has inverted: PICO-8 is now leading the architectural design of Voxatron. He is porting PICO-8's entire fantasy console ecosystem back into Voxatron, including the PNG cartridge format, cart browser (SPLORE), cartridge sharing mechanisms, and exporter pipeline. Because Voxatron's scripting API is built as a direct superset of PICO-8's API, developers can run existing PICO-8 scripts inside Voxatron and render them directly into the 3D voxel volume. White commits to shipping a major fantasy console update for Voxatron within the year.
“At the moment I feel like I'm sort of in the kitchen making snacks and I can hear everyone laughing and talking in the other room, and at 1.0 I just want to join the party and drink some wine.” — Joseph White
[48:58](https://www.youtube.com/watch?v=87jfTIWosBw&t=2938s) Q&A: Choosing Lua and the Cuteness of the Virtual Machine
White addresses why PICO-8 uses Lua instead of a retro dialect like BASIC. Nostalgia originally drove him to attempt a BASIC implementation, but lacking formal compiler training—joking that he took a philosophy degree specifically to avoid a university paper on compilers—he initially decided to transpile BASIC source code into Lua. Working under the hood with Lua led him to study its clean C source code and fascinating language history, dissolving his initial reservations (such as Lua's 1-based table indexing, which can simply be indexed at zero anyway).
When asked whether Lua itself qualifies as a "cute" language, White agrees enthusiastically. Because PICO-8 meters its simulated CPU cycle budget via the quantity of Lua virtual machine instructions executed per frame, the VM feels less like an abstract hardware abstraction layer and more like a living creature. Users can project human empathy onto the runtime engine, imagining it as an earnest little animal busily toiling away inside the computer to keep the game running.
“One aspect of cuteness, I think, is that you can project human qualities on the thing and feel like it's a little animal earnestly working away, and that's how I feel about the Lua virtual machine.” — Joseph White
[51:10](https://www.youtube.com/watch?v=87jfTIWosBw&t=3070s) Q&A: Retro Hardware DNA and Conscious Constraints
Asked about the historical systems that influenced PICO-8's aesthetic and interface, White enumerates several key retro microcomputers: - **Commodore 64:** Heavily shaped PICO-8's palette logic. While the colors differ, PICO-8 adopted the C64 demoscene technique of hue-shifting ramps, branching tonal gradients, and unconventional color-replacement tricks that pixel artists had spent decades refining. - **Amiga:** Directly inspired the vertical layout, pattern structure, and functional feel of PICO-8's integrated tracker audio tool. - **BBC Micro:** Inspired the immediate tactile feedback of turning on a machine, dropping straight into a raw command prompt, and writing executable code from line one. - **Enhanced Graphics Adapter (EGA):** Provided inspiration for bold, vibrant colors, though White softened EGA’s blunt, garish tones into warmer tertiary hues.
When asked whether the fantasy console framework represents an objectively "better" methodology for video game development or merely an interesting aesthetic niche, White stresses that PICO-8 is an intentionally hyper-specific artifact. The broader lesson he hopes to offer the design community is not that every game should look like a retro cartridge, but that creators should remain intensely mindful of how their chosen tools reach into and shape their creative process.
“If I'm trying to offer something to improve the process of making games, it's not this particular choice, it's the idea that you can be conscious of the reach.” — Joseph White
[53:20](https://www.youtube.com/watch?v=87jfTIWosBw&t=3200s) Tools as Creative Manifestos and the Problem of General-Purpose Engines
Closing the presentation and moving into the audience Q&A, Joseph White reiterates that software tools are not passive instruments existing in isolation from the work they produce. Rather than treating an engine or editor merely as a utility to execute pre-formed ideas, creators can treat toolmaking itself as a central component of artistic expression. As Joseph White puts it: “You can incorporate designing and developing tools as part of your creative process.”
An audience member asks what constitutes an "un-cozy" engine or programming environment under this philosophy. White explains that an un-cozy tool is typically any general-purpose engine designed to be as universal and feature-exhaustive as possible, citing standard IDEs or broad engines like Unity. However, he quickly qualifies that this is not an outright dismissal of such platforms. Unity contains distinct cozy sub-spaces within its ecosystem and successfully eliminates severe friction points, such as the headaches of cross-platform porting. For some developers, wrapping that complexity away inside an engine works, even if knowing the underlying machinery exists might bother others. White invokes the metaphor of ascending a ladder: the ideal setup allows a creator to climb up the ladder and then kick it away, freeing them from having to worry about what is happening on the outside.
[54:58](https://www.youtube.com/watch?v=87jfTIWosBw&t=3298s) The Lack of True Red and PICO-8 as an Unintentional Self-Portrait
The discussion turns to the sensory constraints of PICO-8's palette when an audience member asks about the conspicuous absence of pure red, asking whether the missing color prevents designers from depicting violence and blood. White notes that there are indeed surprisingly few violent PICO-8 titles, partly because the engine's graphical restrictions make it difficult to render violence in a gruesome way. While he would love to claim that this was a deliberate ideological choice to curb violent content, the reality comes down to personal aesthetics: White simply dislikes straight primary red and raw primary tones in general. The color labeled red in PICO-8 is actually a soft pinkish-red, a shade he had used across earlier personal projects. Beyond his color preference, applying that strange pink-red tone across the top and bottom toolbars of the editing suite served as an intentional visual disruptor. While typical development environments default to clean, corporate palettes of white and blue, the odd "Play-Doh bar" signaled that PICO-8 was not restricted to any single demographic or serious professional mould.
This reliance on personal taste prompts an audience member to ask whether PICO-8, and by extension the games created on it, essentially functions as an indirect self-portrait of White. White smiles at the tension between his desire to empower independent creators and his own attachment to the platform's aesthetic signature. He acknowledges that while his stated goal is to grant authorship entirely to the community, he still feels an instinctive, greedy impulse to share credit for the work produced inside the fantasy console. “It's unavoidable that anything you make is going to be a reflection of of you I think,” White admits, accepting that his idiosyncrasies inevitably shape everything built on the platform.
[57:11](https://www.youtube.com/watch?v=87jfTIWosBw&t=3431s) Open Source, the "Secret Basement," and Hardware Offshoots
The conversation next addresses how open-source software and community-built tools align with the cozy philosophy. White expresses genuine appreciation for third-party open-source implementations of the PICO-8 API, emphasizing that alternative runtimes provide developers with peace of mind by guaranteeing their cartridges will survive indefinitely into the future. Nonetheless, he defends his decision to keep PICO-8's core proprietary for now. With a conspiratorial grin, he jokes that one reason is the existence of a “very large secret basement to PICO-8 that I don't want anyone to know about yet,” pleading with the audience not to tell anyone.
More seriously, White argues that premature open-sourcing would fragment the platform before its cultural norms could fully solidify. “If it was open source at this point there would be many variations of PICO-8 that would sort of eat away at that shared experience,” White warns, stressing that the value of the platform stems from everyone understanding the exact same boundaries—the fixed cartridge limits, the 16-color palette, and the screen resolution. While the system should eventually become more open and fixable to guarantee long-term software preservation, immediate openness would dilute the communal baseline.
In a final brief exchange, an audience member asks about physical hardware and micro-scale variations. White highlights community hardware experiments such as the Pico Boy created by Josh Blood, handhelds with minuscule screens that emulate the PICO-8 ethos, as well as fringe creative experiments like the "Tiny TV Jam," where developers were challenged to design games for an 11-by-10 voxel television display. The host then closes the session, reminding attendees to deposit their lunch discussion topics into the collection box before the coffee break and leading a round of applause for White.
- **Open Source Preservation vs. Current Cohesion:** Third-party API clones guarantee future software preservation, but White keeps the core engine closed-source to prevent forks from fracturing the universal standard (fixed screen size, 16-color palette, token/cartridge limits). - **Physical and Ultra-Low-Res Spin-Offs:** Community members have extended the fantasy console philosophy into physical hardware (such as Josh Blood's handheld Pico Boy) and extreme resolution jams (such as the Tiny TV Jam with an 11×10 display).
## Notable quotes > [40:36](https://www.youtube.com/watch?v=87jfTIWosBw&t=2436s) In a cozy design space you don't feel afraid to do anything wrong, you can leave your ego behind and not try to be impressing anybody or anything like this, you just want to make something for the love of making. — Joseph White
> [53:20](https://www.youtube.com/watch?v=87jfTIWosBw&t=3200s) You can incorporate designing and developing tools as part of your creative process. — Joseph White
> [39:00](https://www.youtube.com/watch?v=87jfTIWosBw&t=2340s) When you're a designer and you get into a design rat hole, into a quagmire, the only way to get out is to pop up one frame of your stack and sort of do meta-design and see what are the boundaries that you're operating inside. — Joseph White
> [57:11](https://www.youtube.com/watch?v=87jfTIWosBw&t=3431s) If it was open source at this point there would be many variations of PICO-8 that would sort of eat away at that shared experience — Joseph White
> [09:54](https://www.youtube.com/watch?v=87jfTIWosBw&t=594s) When you see glitches in games or anything, it sort of shows the underlying material of the system — Joseph White
> [04:03](https://www.youtube.com/watch?v=87jfTIWosBw&t=243s) I want people to just make something, capture the concept, and then just move on to something else and to feel okay to do that. — Joseph White
## Mentioned Joseph White, PICO-8, Voxatron, Lexaloffle Games, NYU Game Center, Zen Puzzle Garden, Chocolate Castle, Anna Anthropy, PuzzleScript, Twine, Lua, Jumpy, SPLORE, Commodore 64, Amiga, BBC Micro, Jasper's Journeys, Suspension and Souls, Xcode, Macintosh, PICO-16, PICO-64, Enhanced Graphics Adapter (EGA), Unity, Josh Blood, Pico Boy, Tiny TV Jam, Walt Disney
## Video description Joseph White PICO-8 and the Search for Cosy Design Spaces June 23, 2018
Development tools can play a creative role in shaping the work made with them; they can be made to not only implement, but also to guide and tease out ideas, or even to operate as a design manifesto.
This talk retraces the design of the fantasy console PICO-8 with these goals in mind, embracing the fuzzy boundary between tools and creative process, and the influence that user-made PICO-8 cartridges have had on PICO-8 itself.
Joseph White is a Tokyo-based designer and software author. He formed Lexaloffle Games in 2003 in order to pursue his interests in game design, graphics programming, electronic music, and creative tools. He is currently developing the concept of fantasy consoles (PICO-8, Voxatron) and exploring their use in creativity and education. With his wife Natsuko, Joseph also co-runs Pico Pico Cafe: an event space and meeting place for artists and developers.
For more from the NYU Game Center visit gamecenter.nyu.edu
[Source](https://www.youtube.com/watch?v=87jfTIWosBw)