Andrew Price Concedes Blender UI Flaws, Ends Tutorial Boycott
Blender
Interface overhauls fail when superficial user polls prioritize beginner simplicity over the complex workflow flexibility required by production pipelines.
AI-assisted summary of Andrew Price - Improving Blender's UI — original source. Check the original for full context.
Source published:
Key ideas
- Andrew Price walked back his publicized Blender UI proposal, admitting that his 8.7/10 community survey rating was an illusion because casual users favor immediate visual simplicity over production flexibility. (10:48)
- Technical audits by professional UX designers revealed critical flaws in Price's redesign, including rigid top-level tabs that broke split-screen multitasking and predictive menus that disrupted muscle memory. (12:34)
- Price proposed establishing an unbiased, dedicated UI team that tests low-fidelity wireframes to funnel community feedback into vetted developer specifications. (22:21)
- Blender Foundation Chairman Ton Roosendaal pushed back against centralized UI control, defending the open movie model that pairs module developers directly with production artists. (37:16)
- Price retracted his ultimatum to pause making Blender tutorials until the interface was overhauled, acknowledging his naivety regarding the pace and complexity of open-source development. (45:07)
Detailed notes
## Background Published on YouTube by the official Blender channel on October 25, 2013, this presentation features Andrew Price, owner of BlenderGuru.com and full-time 3D tutor, addressing the heated debate surrounding Blender's interface. According to the description, the session explores the problems, politics, and potential solutions of the UI debacle, concluding with an extensive audience Q&A.
## TL;DR Andrew Price candidly reflects on the controversy sparked by his radical Blender interface redesign proposal, acknowledging how consulting professional UX designers exposed critical structural flaws in his original mockups. He breaks down why popular user polls and visual mockups can mislead software development, demonstrating how rigid top-level tabs, predictive menus, and screen-pinching headers fail under production conditions. To chart a realistic path forward, Price proposes an unbiased, dedicated UI team that focuses on low-hanging usability fruit, consistent interaction standards, and standardized defaults like left-click select. The talk closes with an energetic, multifaceted debate with audience educators and Blender Foundation Chairman Ton Roosendaal over centralized interface governance versus real-world production needs.
## Atmosphere & style The presentation carries a candid, disarming tone, opening with self-deprecating humor as Price readily admits his early naivety in thinking he could single-handedly redesign Blender in Photoshop. As the session transitions into the open floor, the atmosphere shifts into a spirited, high-stakes town hall debate where power users, design teachers, and Ton Roosendaal passionately defend their ground. It feels refreshingly transparent, marked by genuine professional vulnerability, tension over open-source development philosophies, and an ultimately collaborative spirit that earns warm audience laughter and enthusiastic applause.
## Bulletin - [10:48](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=648s) Andrew Price walked back his publicized Blender UI proposal, admitting that his 8.7/10 community survey rating was an illusion because casual users favor immediate visual simplicity over production flexibility. - [12:34](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=754s) Technical audits by professional UX designers revealed critical flaws in Price's redesign, including rigid top-level tabs that broke split-screen multitasking and predictive menus that disrupted muscle memory. - [22:21](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1341s) Price proposed establishing an unbiased, dedicated UI team that tests low-fidelity wireframes to funnel community feedback into vetted developer specifications. - [37:16](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2236s) Blender Foundation Chairman Ton Roosendaal pushed back against centralized UI control, defending the open movie model that pairs module developers directly with production artists. - [45:07](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2707s) Price retracted his ultimatum to pause making Blender tutorials until the interface was overhauled, acknowledging his naivety regarding the pace and complexity of open-source development.
## Key takeaways - [01:18](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=78s) Usability flaws carry a measurable business cost; lowering interface barriers expands the user base, driving long-term donations that fund full-time core developers. - [07:13](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=433s) Radical interface redesign proposals provoke intense backlash because existing power users perceive major changes as the destruction of their invested learning time. - [10:48](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=648s) Public usability surveys generate misleading data because voters consistently favor uncluttered visual ease of use over the complex tool density required for real production. - [12:34](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=754s) Global top header tabs pinched vertical viewport space and made multitasking impossible by restricting artists from viewing two disparate toolsets simultaneously. - [14:42](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=882s) Predictive context menus that hide or reorder tools based on selection prevent users from achieving an autonomous state reliant on spatial muscle memory. - [16:30](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=990s) High-fidelity mockups are counterproductive in UI design discussions because stakeholders fixate on cosmetic aesthetics rather than evaluating structural workflow logic. - [20:10](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1210s) Contextual options should be grayed out rather than removed entirely, as vanishing elements disorient users and create cognitive friction. - [20:10](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1210s) Factory defaults should cater to newcomers by aligning with industry conventions like left-click select, while retaining legacy preferences for existing veterans. - [22:21](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1341s) Direct democracy fails in software development; an unbiased, UX-trained design team is required to translate disparate community feedback into cohesive technical specs. - [24:42](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1482s) UI initiatives should start with uncontroversial low-hanging fruit and low-fidelity wireframing tools like Balsamiq to build trust before tackling systemic overhauls. - [29:26](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1766s) Rigorous empirical usability testing with beginners exposes interface blind spots that experienced developers and power users fail to anticipate. - [30:19](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1819s) Simplifying software must not patronize beginners; users willingly embrace interface complexity as long as their learning effort yields immediate, noticeable progress. - [37:16](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2236s) Ton Roosendaal argued that UI cannot be governed centrally because specialized domains like rigging and shading require direct artist-developer collaboration within module teams. - [42:40](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2560s) Visual screen tools paired with hover tooltips provide an essential on-ramp, guiding beginners from mouse exploration into rapid, ergonomic two-handed keyboard workflows. - [45:07](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2707s) Andrew Price retracted his public pledge to halt tutorial production, acknowledging that underestimating software development timelines led to unrealistic expectations.
## Detailed walkthrough ### [00:00](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=0s) Introduction and Hindsight on the UI Proposal
Andrew Price introduces his talk on the hotly debated topic of improving Blender's interface. He begins by asking for a show of hands to see how many people in the audience watched his earlier proposal video, and nearly every hand in the room goes up. He admits that when that video first dropped, his confidence was through the roof: “At the time that the proposal went up, I thought it was the cat's pajamas, I thought it was amazing, I thought this is what Blender needs, we need this proposal, this is how Blender should look.”
Since releasing it, however, his perspective has shifted dramatically. By engaging directly with core developers, sifting through intense user feedback, and consulting with a professional UX software designer who readily dismantled some of the proposal's major structural flaws, he uncovered deep underlying problems with his original vision. This presentation serves as an open reflection on what worked, what failed, and how the community can practically chart a course forward.
[01:18](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=78s) Why Step into the UI Debate: The Business Cost of Bad Usability
Addressing the skepticism about why a tutorial creator with no prior software design background would jump into such a notorious hornet's nest, Price explains that his journey began when he read a book on user interface design and usability. He quickly devoured several more titles, discovering a recurring theme: tiny, overlooked usability flaws routinely destroy multi-million-dollar software investments. In the early days of internet banking, for instance, financial institutions lost massive swathes of customers simply because their web interfaces were too bewildering to navigate, driving users into the arms of competitors with intuitive portals.
Recognizing that Blender has long possessed an external reputation for being notoriously difficult to learn, Price wondered whether interface friction was quietly stunting Blender's own growth. To test this hypothesis against real-world feedback rather than internal assumptions, he launched a discussion thread on the CGTalk / CG Society forums titled *"Why don't you use Blender? A serious discussion."* His goal was to invite blunt rejections from artists working in other 3D applications, noting that while criticism stings, it inevitably exposes uncomfortable truths. Despite some defensive Blender community members jumping in, the thread exploded into a 20-page discussion highlighting identical pain points: steep learning curves, alien user experience conventions, and an overall environment that felt like an arbitrary hazing ritual.
```mermaid flowchart TD accTitle: The Open-Source Growth Cycle Driven by UI accDescr: A cyclical flowchart illustrating how an inviting user interface drives community growth, donations, developer funding, and software improvements.
A["More Inviting & Usable UI"] --> B["Broader Inflow of New Users"] B --> C["Increased Long-Term Donations"] C --> D["More Full-Time Developers Hired"] D --> E["Better Overall Blender Software"] E --> A ```
Price argues that this feedback chain forms the foundational lifeblood of open-source development. He summarizes the economic logic behind his intervention: “If we could create a better interface, one that was more inviting to new people, then as a result of that we could get more users overall, and then as a result of more users, you could get more donations in the future—not short term, but down the line, two or three years.” With double the user base and double the donations, the Blender Institute could hire more full-time developers, directly accelerating Blender's technological capability.
[05:02](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=302s) Drafting the Campaign and Developing the Proposal
Armed with his usability notes, Price initially began campaigning by recording two videos identifying Blender's violations of basic UI laws. He originally gave them the abrasive title *"Fixing Blender: Why It's Broken,"* a framing he now looks back on with regret: “In hindsight, realized that was a really mean title, one that really didn't start it off on the right foot with developers, that's for sure.” He subsequently softened the title to *"Improving Blender"* to spark a constructive forward-looking discussion rather than appearing purely destructive.
Determined not to remain a passive complainer who merely mocks the software without offering concrete solutions, Price began sketching layout concepts based on the design literature he had read. These sketches soon solidified into a comprehensive, radical mockup proposal that introduced sweeping visual and structural shifts: - A large top header accompanied by top-level tabs and a streamlined sidebar. - Simplified workflows for assigning materials, complete with built-in shader presets. - A redesigned rendering interface featuring dedicated progress bars and estimated completion timers. - A modular post-processing workspace with drop-down menus for common visual effects, aiming to provide an accessible ramp for incoming beginners.
[07:13](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=433s) The Community Backlash and the Nature of User Investment
Once the proposal reached the broader community, the response was swift, intense, and often venomous. Price recalls that the Blender Artists forums became essentially unapproachable for weeks. Out of curiosity, he audited the discussion across the web and tallied 7,015 total reactions:
- 856 posts on Blender Artists - 1,240 comments on BlenderGuru.com - 919 comments on BlenderNation - 3,913 comments on YouTube - 177 comments on secondary forums
The sheer volume of engagement—which included numerous personal insults directed at him—was not something he viewed with pride, but rather as proof of how protective users are of their software environment. Price realized that radical redesigns pose an existential threat to seasoned veterans: “When somebody has spent the time to learn a new piece of software, when somebody suggests a change and a complete rewrite of it—or not a rewrite, but a new skin for the interface, something like that—it's basically asking people to destroy their investment and start over, which of course nobody wants to do.” He highlights a humorous, exasperated tweet from developer Bastien Montagne to illustrate how chaotic the debate had become, pointing Bastien out in the back of the lecture room to share a laugh with the audience.
[09:25](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=565s) Gauging Sentiment: The User Survey and Initial Data
Recognizing that unmoderated forum comments devolved into endless contradictions—where every well-argued opinion was immediately cancelled out by an equally persuasive opposing comment—Price organized an objective survey to quantify sentiment across the community. The questionnaire asked respondents to specify which specific proposal elements they favored or disliked, as well as rank their overall impression on a scale from 1 (hating everything) to 10 (loving everything).
Early poll breakdowns revealed a clear hierarchy of preferences: - Highly favored features: A cleaner aesthetic, tabbed navigation, and dedicated layer management panels. - Highly disliked features: The oversized, mobile-style buttons, which suffered a steep drop in approval. Price acknowledged that he anticipated the backlash against the gigantic buttons even while designing them.
Despite the loud hostility on forum threads, the quantitative distribution of the 1-to-10 overall ratings leaned surprisingly positive, demonstrating a distinct disconnect between the vocal anger in comment sections and the broader community's appetite for interface refinement.
[10:48](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=648s) The Illusion of Usability Polls
Andrew Price recounts the initial validation he felt after polling the Blender community on his interface proposal. With roughly 2,000 votes cast, the proposal received an overwhelming mean rating of 8.7 out of 10. Everything seemed set to declare the design an absolute success—until three days prior to the talk, when Andrew recorded a two-hour podcast with Duncan McNeill, a UX software designer with seven years of industry experience auditing client workflows and re-architecting software usability.
The conversation completely overturned Andrew's confidence. Duncan highlighted fundamental structural problems in the proposal and challenged the premise of the community vote. As Andrew recalls, Duncan delivered a reality check that knocked the wind out of his sails: “Usability polls rarely represent accurate data as people will always favor vote in favor of ease of use over flexibility.” Novice and casual voters instinctively gravitate toward large, uncluttered buttons and visually clean layouts, cheering for immediate accessibility without factoring in whether that structure can scale to complex, flexible professional work. Andrew admits that the high poll numbers were essentially meaningless, taking a sheepish pause for a sip of water while acknowledging the wasted effort.
```mermaid flowchart TD accTitle: The Fallacy of Interface Polls accDescr: Diagram contrasting superficial poll results with the realities of professional software design. subgraph Poll["Superficial User Poll"] A["Clean, simple visual mockup"] --> B["Users vote for immediate ease of use"] B --> C["8.7 / 10 Approval Rating"] end subgraph Reality["Professional Reality"] D["Complex production pipeline"] --> E["Demands high flexibility & dense toolsets"] E --> F["Simple mockups break under production pressure"] end C -.->|"Contradicts"| F ```
[12:34](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=754s) Flaws in the Proposal: Tabs, Lost Vertical Space, and Tab Overkill
Dissecting the specific technical failures of his proposal, Andrew points first to inflexibility. His concept relied on a top header bar filled with task-specific tabs, which seemed practical when mocking up a simple default cube. In that isolated scenario, dragging down a sphere or picking modeling tools felt intuitive. However, the system collapsed when applied to production pipelines—such as character animation, where an artist simultaneously requires the video sequence editor for audio playback and dedicated animation toolsets. Because the proposal tied active tools to a single global tab bar, it made viewing two distinct toolsets at the same time impossible, even in split-screen arrangements.
The second and third major flaws were viewport real estate and tab clutter. Placing a dense, horizontal toolbar across the top consumed critical vertical screen space, pinching the 3D viewport into an awkward, ultra-wide aspect ratio. While horizontal arrangements eliminate the endless vertical scrolling introduced after Blender 2.4, they revive old layout crampedness. Furthermore, Andrew had succumbed to tab overkill by creating dedicated top-level tabs for minor subtasks like weight painting without any overarching hierarchy or grouping, cluttering the header with unmanageable noise.
- **Inflexible toolsets:** Grouping tools strictly into singular top tabs prevented artists from accessing multiple disparate toolsets (e.g., animation curves alongside sequencing tools) during complex multitasking. - **Aspect ratio pinch:** Thick horizontal toolbars rob artists of vertical viewport space, reintroducing the widescreen squishing Blender had spent years trying to move away from. - **Tab fragmentation:** Assigning dedicated top-level tabs to niche tasks like weight painting produced a sprawling, unstructured navigation bar.
[14:42](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=882s) The Failure of Predictive Menus and the Autonomous State
The proposal had also championed predictive context menus—such as automatically surfacing a "Bridge" command when right-clicking two selected edge loops with matching vertex counts. Andrew explains why this is deeply flawed in practice: if a user selects two edge loops where one loop has even a single vertex missing, the algorithm will not trigger the prediction. The user is left stranded and frustrated, wondering where the familiar command went, with no visual explanation or feedback indicating why the option failed to appear.
Beyond conditional edge cases, predictive menus disrupt muscle memory and destroy what UX professionals call the "autonomous state." In this state, an experienced artist executes commands entirely on instinct without reading UI labels. If an artist instinctively knows that the third entry down on a context menu is Subdivide, an unpredictable menu that rearranges or omits options based on selection context will cause misclicks and halt productivity. (Andrew's explanation is punctuated by a momentary live audio glitch on the conference microphone, prompting a quick "What was that? Hello?").
> “Once you've been using software for a long enough time you want to get to the stage where you're able to use it autonomously that's what um UX software designers say is like the ideal state where you can just sit there and without thinking about it just work work work work work and get the job done and finished.” — Andrew Price
[16:30](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=990s) Pitfalls of Full Mockups and Material Presets
Andrew also addresses omitted concepts and presentation blunders, noting that his mockups failed to illustrate split-screen capabilities or clarify that the sidebar could accommodate panels like the Outliner. He then examines material presets. While presets are a fixture in modern 3D suites, providing instant one-click materials (such as procedural wood) can become a pedagogical trap: “When users approach a software and they get hooked on presets if the presets don't explain clearly how that thing was created... over time that new user will not have learned how that wooden material was created so it's not good for learning.”
A deeper strategic mistake was creating polished, high-fidelity mockups in software like Photoshop. Highly finished renders actively distract stakeholders from foundational architectural issues. Rather than debating structural workflows, viewers fixate on trivial aesthetics: the specific shade of a button, its pixel dimensions, or why an icon is located in a particular corner. Andrew notes that professional UX designers avoid this trap by presenting rough, hand-drawn wireframe sketches, which force clients to evaluate spatial relationships and overall workflow logic rather than cosmetic styling.
[18:38](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1118s) Salvaging the Core Ideas
Despite the missteps, Andrew argues that several foundational principles from the proposal remain essential for modernizing Blender. First among these is interface consistency—the number one grievance echoed by artists across the conference. General usability standards must be applied universally across Blender's disparate editors and tools rather than treated as an afterthought.
Logical tool grouping also remains an urgent priority, even if top tabs were the wrong mechanism to achieve it. In standard Blender, sculpting and modeling controls are scattered randomly across multiple floating panels, toolbars, and menus, forcing users to constantly open and close panels and destroying their autonomous momentum. Other salvageable concepts include: - **Clean sidebar integration:** Moving notifications into a dedicated sidebar rather than relying on jarring pop-up dialogue boxes or fleeting status text attached to the cursor. - **History and layer management:** Implementing dedicated visual undo history lists to help new users comprehend the sequence of past operations. - **Immediate system feedback:** Ensuring responsive visual state changes when buttons are clicked, and automatically switching dense, high-poly geometry to low-poly bounding proxies during viewport transforms to eliminate cursor lag.
[20:10](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1210s) Context Menus, Right-Click Defaults, and Self-Critique of the Proposal
Andrew Price revisits the specifics of his interface mockup, particularly right-click context menus and mouse button bindings. While right-click menus can function well, their available options must remain strictly stable rather than shifting unpredictably based on predictive heuristics. Price cites an interaction design principle he encountered in literature after assembling his mockups: options unavailable for a given task must be grayed out rather than hidden, because when interface elements vanish, users become disoriented wondering where functionality went. On the matter of mouse behavior, he revisits the feedback from the CG Society survey, where Blender's nonstandard right-click select was a primary barrier to entry. Following advice from software designer Duncan, Price argues that Blender should adopt left-click select as its factory default to align with user experience conventions, while explicitly guiding existing users on how to revert to right-click selection via a legacy mode in User Preferences.
Reflecting on his earlier publicized redesign, Price admits it suffered from critical architectural flaws. It provided seductive visual polish—what he calls "eye candy"—that thrilled beginners on platforms like YouTube, but it was fundamentally inflexible for advanced workflows requiring simultaneous tasks. Furthermore, it was overly ambitious: features he had assumed were trivial turned out to represent several years of full-time developer labor. He acknowledges that pitching such massive, unvetted changes raised unrealistic expectations across the Blender community, even if a handful of the underlying ideas remain viable.
- Graying out inactive UI controls preserves spatial memory, whereas removing them outright creates cognitive friction. - Existing power users know how to navigate the User Preferences editor to toggle settings, while newcomers do not; hence, defaults should cater to newcomers. - “You should never ever make an option vanish from a user interface because when something vanishes it confuses users and they wonder where did that thing go so it should always gray out and never actually vanish,” Price explains regarding context menus.
[22:21](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1341s) The Case for a Dedicated UI Team
Turning to viable solutions, Price highlights Ton Roosendaal's prior mention of establishing an official UI team. Citing Duncan, Price stresses that direct democracy fails in software design; gathering disparate opinions from across the community without a cohesive vision yields muddled results. Instead, Blender requires a small, dedicated team with absolute authority over interface decisions to bridge the chasm between end users and core developers. Developers are overextended and focused on code architecture, while users understand day-to-day workflow pain points but lack technical implementation context.
Price emphasizes that such a team must possess UX experience and, above all, remain unbiased. Every faction in an open-source project holds inherent biases: beginners demand simplicity, advanced users demand infinite flexibility, and programmers prioritize clean code over ergonomic interaction. To illustrate this fundamental tension, Price quotes a UX design book: “The goals of the programmer and the goals of the user are dramatically different. The programmer wants the construction process to be smooth and easy. The user wants the interaction with the program to be smooth and easy. These two objectives almost never result in the same program.” Following an open inquiry on Facebook, Price noted numerous community members with professional UX backgrounds who could form this autonomous design layer.
```mermaid flowchart TD accTitle: Blender UI Team Communication Pipeline accDescr: Diagram showing user requests passing through a dedicated UI team to filter and validate before reaching core developers.
subgraph Community ["User Base"] U["End Users<br>(Feature requests & pain points)"] end
subgraph Bridge ["Interface Governance"] UI["Dedicated UI Team<br>(UX experienced & unbiased)"] end
subgraph Core ["Engineers"] DEV["Core Developers<br>(IRC & code construction)"] end
U -->|"Propose ideas / report friction"| UI UI -->|"Filter validity & prototype low-fidelity wireframes"| UI UI -->|"Deliver vetted, actionable specs"| DEV ```
[24:42](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1482s) Workflow for UI Governance: Low-Hanging Fruit, Wireframing, and Feedback Validity
Price details how an active UI team should operate in practice. At present, individual users have nowhere constructive to send interface critiques; an obscure workflow quirk—such as needing to hold Shift while deleting an image in the UV/Image Editor so it does not persist in the scene file—gets ignored when voiced on forums because developers cannot evaluate individual complaints amidst their development workload. A UI team provides a formal funnel to assess, prioritize, and translate these community observations.
The strategy should prioritize "low-hanging fruit"—small, uncontroversial friction points whose resolution immediately builds goodwill and proves the team's competence. When proposing new interfaces, the team should avoid high-fidelity renders and instead publish deliberately low-fidelity wireframes using tools like Balsamiq or Axure, which keep discussions focused on interaction flow rather than aesthetics. Furthermore, the team must evaluate community feedback through structured validity tiers:
| Feedback Validity Tier | Nature of Community Feedback | Recommended Response | |:--- |:--- |:--- | | **Face-Value Feedback** *(Lowest)* | Knee-jerk cosmetic reactions (e.g., "it looks like Modo," "it looks like 3ds Max," or disliking button colors). | Disregard entirely. | | **Content / Workflow Feedback** *(High)* | Concrete workflow critiques detailing practical operational bottlenecks and functional requirements. | Prioritize, synthesize, and format into developer-ready specifications. |
Price closes his formal talk by hoping that future contributors learn from his design mistakes, prompting applause from the conference hall before opening the floor to audience questions.
- High-fidelity visual mockups cause community debates to degenerate into cosmetic arguments over aesthetics instead of structural ergonomics. - Tools like Balsamiq and Axure enforce a hand-drawn aesthetic that directs feedback toward core usability. - “The low-hanging fruit, the easy stuff, should definitely be tackled first,” Price emphasizes, noting it establishes trust before major systemic changes are attempted.
[28:16](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1696s) Q&A: Beginner Realities and Formal Usability Testing
The session transitions into an open audience Q&A. An attendee (identified by Price as an Australian in the back row) takes the microphone to raise a question regarding empirical data on newcomers. The attendee observes that almost everyone attending the conference is an advanced power user making assumptions about beginners; in his own teaching practice, he encountered a student who could not even dismiss the Blender splash screen because they were unable to locate an "OK" button. He asks whether anyone has conducted structured empirical research into novice interaction.
Price responds by discussing formal usability testing as conducted by major corporate software developers. He describes the standard methodology: test subjects are placed in an isolated room with a proctor holding a clipboard instructing them to perform basic tasks, while developers observe behind two-way mirrored glass, often reacting in disbelief as users struggle with interfaces the engineers presumed were self-explanatory.
- “With everybody in this room I think is probably a pretty experienced Blender user and a lot of assumptions seem to be made about beginner Blender users. Has anyone done any research into that?” the audience member asks. - Price highlights that while commercial enterprises regularly employ two-way mirrors and observation protocols, rigorous usability testing is historically rare in open-source projects due to high costs.
[29:26](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1766s) The Need for Formal Usability Testing
When developers or power users design an interface, they rely heavily on internal assumptions—such as believing a new user will have no trouble dismissing a splash screen. In practice, observing a user encounter the software for the first time often exposes critical friction points that experienced users have become blind to. To bridge this blind spot, Andrew Price proposes investing in real empirical research. He points out that the community lacks hard data because Blender has never undergone structured usability testing. “If the Foundation was open to it, I'd gladly sponsor a usability company to actually do some usability testing on Blender; we could have a much better idea of the key problems with it,” Andrew offers to the room before opening the floor to audience questions.
---
[30:19](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1819s) "Dumbing Down" vs. The Reward of Complexity
An audience member with approximately twelve months of Blender experience challenges Andrew’s design philosophy, raising a concern about oversimplification. Drawing on his own experience learning software from YouTube tutorials, the attendee argues that modern beginners are neither helpless nor naive; if they encounter an obstacle, their immediate instinct is to search Google rather than abandon the software. The audience member fears that redesigning Blender to look excessively simple risks making it look like an amateur toy and patronizing the user base. “What worried me most about your proposal was the idea that you are treating the beginner as a dummy—they're ignorant, but they're not stupid,” the attendee stresses, arguing that users willingly tolerate complexity as long as the investment pays off.
```mermaid flowchart TD accTitle: User Behavior Hierarchy When Learning Software accDescr: How users approach unfamiliar software from self-discovery down to abandonment or search.
Start["Encounter New Software"] --> Step1["Tier 1: Independent Discovery<br>(Click around / explore directly)"] Step1 -->|"Success"| Continue["Productive Workflow"] Step1 -->|"Failure / Frustration"| Branch{"Support Path Available?"}
subgraph HelpPaths["Escalation Routes"] Branch -->|"In-person mentor present"| Step2["Tier 2: Direct Assistance<br>(Classroom teacher / peer)"] Branch -->|"Self-guided learning"| Step3["Tier 3: Online Search<br>(Google / tutorials)"] Branch -->|"Zero initial reward"| Abandon["Drop Software Entirely"] end
Step2 --> Continue Step3 --> Continue ```
Andrew responds by citing human-computer interaction studies that investigate how users actually learn applications. Users almost universally try to explore and figure things out on their own before turning to any other method. If they encounter immediate walls, they either drop out or seek help from an instructor, which is why structured classroom environments succeed so well. Searching online tutorials is only a third-tier fallback. If an interface makes even basic interactions incomprehensible from the outset, many prospective users conclude that the program is unnecessarily hostile. “A lot of new people do go to Google, and a lot of people do quit as well, but we don't know the statistics on that,” Andrew notes, emphasizing that early software feedback must validate the user's effort so they feel motivated to continue.
- The audience member emphasizes that beginners accept a steep learning curve: “I don't mind Blender looking complicated so long as there's reward for my effort in learning it.” - Computer science research shows the primary learning progression: direct self-guided exploration first, personal instruction second, and web search third. - Without an immediate sense of progress or clear feedback, many prospective users quit before ever attempting to search for solutions.
---
[33:55](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2035s) Classroom Insights, Eye-Tracking, and the Suzanne Monkey Trap
A teacher in the audience who instructs sixty students notes that beginners frequently identify low-hanging usability flaws that developers overlook. When watching a novice search for a tool in an unexpected location, it becomes immediately obvious where natural intuition expects that control to be. The instructor suggests running structured eye-tracking sessions with webcams to monitor gaze paths, search patterns, and pupil dilation as proxies for cognitive load and emotional tension during interface navigation.
Andrew agrees that direct observation disproves developers' comfortable assumptions about user behavior. To illustrate how unpredictable beginners can be, he recalls teaching his very first Blender class back in high school. He had instructed the room to press `Shift + A` and add a plane to build a basic particle firework system. Instead, the students saw the mesh menu entry for "Monkey" (Suzanne), and half the class immediately clicked it. Because the students did not know how to undo or delete the geometry, Andrew spent the entire lesson running from monitor to monitor just clearing monkey heads from their viewports. “Nobody made the actual finished result because I overestimated basically a beginner's ability to create something simple,” Andrew reflects.
---
[37:16](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2236s) Ton Roosendaal on Decentralized Development vs. Central UI Teams
Ton Roosendaal, Chairman of the Blender Foundation, steps up to strongly challenge Andrew's depiction of the development process. Ton expresses surprise at the suggestion that an invisible wall separates Blender’s coders from its artists. He explains that since the launch of the open movie projects in 2005, Blender’s development model has deliberately placed artists side-by-side with developers to stress-test tools under real production pressure—giving rise to Blender's animation, fluids, and Cycles rendering systems. Ton argues that Blender’s interface cannot be managed from an ivory tower or centralized UI committee, because the interface spans deep, specialized domains like rigging, motion tracking, node shading, and modeling (where community leaders like Jonathan Williamson coordinate directly with developers).
> “In my role as a chairman of the Blender Foundation and the way how I've been organizing the project, I've always and always try to get the user central—every developer gets kicked by me continuously if they do anything that even smells like making their lives easier and making users' life more difficult.” — Ton Roosendaal
Ton questions why Andrew felt disconnected from this workflow when hundreds of contributors already participate in these public channels. Andrew clarifies that his proposed UI team and mockups were not meant to discredit domain-specific module teams, but rather to address global, cross-cutting usability inconsistencies that slip between module boundaries. He gives the example of deleting datablocks—where hitting delete fails to purge an image unless the user knows to execute a `Shift + Delete` command. Furthermore, Andrew explains that ordinary users and third-party educators often feel intimidated reaching out directly to core developers out of fear of inconveniencing them or disrupting their technical workload.
[40:50](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2450s) Developer Communication and Interface Design Politics
Addressing the friction between community members and programmers, Andrew points out that everyday users hesitate to reach out directly to developers because they fear hostile responses or being dismissed to public forums. Many artists are intimidated by IRC or find developer mailing channels unapproachable, creating an ongoing disconnect between the community and core contributors. Ton Roosendaal responds from the floor, agreeing that communication pipelines must function smoothly and emphasizing that visibility matters. He recalls how Matt Ebb served as a dedicated, recognizable public face during the Blender 2.5 interface overhaul—writing usability articles, answering questions, and maintaining an open dialogue with artists. Ton stresses that Blender already possesses world-class talent and seasoned interface designers, but cautions that design cannot simply follow whatever external opinion shouts loudest.
Highlighting the subjective nature of user experience discussions, Ton argues that progress requires setting firm parameters before drawing wireframes. Because user interface debates invite endless contradictory suggestions, the development team must first establish concrete goals before committing to any layout. As Ton puts it, “Design is always based on first narrowing down and say this is what we want this is where we go to and this is what we try to do then you make an interace and forever you design you can make different ones.”
- Users often avoid contacting developers directly out of fear of being reprimanded or redirected to Blender Artists. - IRC remains an unfamiliar and awkward communication barrier for a substantial portion of the community. - Matt Ebb’s public-facing role during the Blender 2.5 redesign is cited as a successful model of transparent, trusted developer-to-artist communication.
---
[42:40](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2560s) Ergonomics, Beginners, and Mouse vs. Keyboard Interaction
A design educator in the audience steps forward to share experiences teaching Blender over two years to a wide demographic spectrum, ranging from university students and cross-training 3D professionals to young children and computer-illiterate seniors. The speaker observes that almost all newcomers naturally gravitate toward single-handed mouse navigation. However, the speaker cautions against Andrew's mockups leaning too heavily toward mouse-driven interactions on screen, arguing that working with both hands—left hand dedicated to the keyboard and right hand on the mouse—is far better for posture and motor engagement. While beginners experience a slight initial hurdle placing their left hand on the keyboard, by the second or third lecture they work significantly faster than single-handed mouse users. The speaker insists: “I think it's both healthier to use both hands because I will use the both brain hemispheres and also for the shoulders it's much more healthier.”
Andrew validates the observation that new users instinctively rely on the mouse, but clarifies that his proposed visual interface is meant to serve as an on-ramp rather than a permanent crutch. Drawing a comparison to Photoshop, Andrew explains that standard software makes core tools visually discoverable so novices can click them immediately; once a user hovers over an icon, a tooltip reveals the shortcut (such as the hotkey "M"), allowing them to internalize the keybindings organically. Through this gradual discovery model, users transition from visual searching into rapid two-handed keyboard workflows without being overwhelmed on day one.
```mermaid flowchart TD accTitle: Progressive Shortcut Learning Workflow accDescr: A diagram illustrating how visual interface elements guide novice users toward keyboard shortcut mastery.
subgraph Discovery ["Novice Phase: Visual Discovery"] A["New user explores screen UI"] --> B["Locates tool visually & clicks with mouse"] end
subgraph Reinforcement ["Transition Phase: Tooltip Reinforcement"] B --> C["Hover reveals tooltip showing hotkey"] C --> D["User repeatedly associates action with key"] end
subgraph Mastery ["Proficient Phase: Two-Handed Muscle Memory"] D --> E["Left hand stays on keyboard shortcut"] E --> F["Rapid dual-handed workflow established"] end ```
- Novices and cross-trainers from other 3D software commonly start by interacting almost exclusively with the mouse. - Ergonomic concerns favor dual-handed operation to reduce shoulder strain and distribute physical workload. - In educational settings, students typically overcome the keyboard hurdle after two to three classes and work much faster thereafter. - Andrew points to Photoshop's convention of pairing on-screen tools with hover hotkeys as the ideal bridge between visual discoverability and power-user speed.
---
[45:07](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=2707s) Sebastian's Question and Andrew's Future Plans
With lunch having been ready for half an hour, the organizers attempt to wrap up the session with one final question. A brief comic moment ensues as an audience member claims the microphone from another attendee who had been waving persistently from the floor, only to hand it over to track artist Sebastian König. Sebastian addresses Andrew directly: “Andrew this is maybe a bit personal question but I would like to ask you what are your future plans what will be your your next step in this situation you created here?”
Andrew laughs and offers a candid, reflective answer about his motivations and missteps. Having produced Blender tutorials for four years at Blender Guru, he felt creative exhaustion and burnout from repeating the same instructional patterns. Wanting to step back and make a lasting, positive contribution to the software, he looked at Blender's usability challenges through the lens of a business owner whose livelihood depends on the application's long-term survival. He worried whether sticking with Blender over a ten-year horizon was viable if basic accessibility hurdles continued to constrain its user growth.
Reflecting on the controversy ignited by his earlier public proclamation that he would halt all tutorial production until Blender's UI was fixed, Andrew openly retracts the ultimatum. He acknowledges his own impatience and overestimation of how quickly open-source design changes can happen: “That was a very bold statement I think uh that's one of my again my shortsightedness and my naivity thinking that the interface could be fixed so simply and um I'd go back on that statement so I'm yeah I would go back to making tutorials.” He concludes by stating that while he will resume recording lessons, he remains eager to collaborate with the UI team on usability refinements if the community still welcomes his input, bringing the lively, passionate session to a close amidst enthusiastic applause.
## Notable quotes > [22:21](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1341s) The programmer wants the construction process to be smooth and easy. The user wants the interaction with the program to be smooth and easy. — Andrew Price
> [30:19](https://www.youtube.com/watch?v=6aIA2LaB2Iw&t=1819s) I don't mind Blender looking complicated so long as there's reward for my effort in learning it. — Audience Member
## Mentioned Andrew Price, Blender, Blender Foundation, Blender Institute, BlenderGuru.com, Blender Artists, BlenderNation, CGTalk, CG Society, YouTube, 3D World Magazine, Duncan McNeill, Bastien Montagne, Ton Roosendaal, Jonathan Williamson, Matt Ebb, Sebastian König, Photoshop, Balsamiq, Axure, Modo, 3ds Max, Cycles, Suzanne, Google, Facebook
## Video description Is it time for an interface upgrade? This presentation covers the problems, politics and possible solutions to this UI debacle. Includes a full Q&A at the end.
About Andrew Price
Owner of BlenderGuru.com, and fulltime Blender tutor. I've written for 3D World Magazine and been featured in books, magazines and websites. My passion is artwork and teaching, but also marketing and problem solving.
[Source](https://www.youtube.com/watch?v=6aIA2LaB2Iw)