View in English

  • Apple Developer
    • Get Started

    Explore Get Started

    • Overview
    • Learn
    • Apple Developer Program

    Stay Updated

    • Latest News
    • Hello Developer
    • Platforms

    Explore Platforms

    • Apple Platforms
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    • App Store

    Featured

    • Design
    • Distribution
    • Games
    • Accessories
    • Web
    • Home
    • CarPlay
    • Technologies

    Explore Technologies

    • Overview
    • Xcode
    • Swift
    • SwiftUI

    Featured

    • Accessibility
    • App Intents
    • Apple Intelligence
    • Games
    • Machine Learning & AI
    • Security
    • Xcode Cloud
    • Community

    Explore Community

    • Overview
    • Meet with Apple events
    • Community-driven events
    • Developer Forums
    • Open Source

    Featured

    • WWDC
    • Swift Student Challenge
    • Developer Stories
    • App Store Awards
    • Apple Design Awards
    • Apple Developer Centers
    • Documentation

    Explore Documentation

    • Documentation Library
    • Technology Overviews
    • Sample Code
    • Human Interface Guidelines
    • Videos

    Release Notes

    • Featured Updates
    • iOS
    • iPadOS
    • macOS
    • watchOS
    • visionOS
    • tvOS
    • Xcode
    • Downloads

    Explore Downloads

    • All Downloads
    • Operating Systems
    • Applications
    • Design Resources

    Featured

    • Xcode
    • TestFlight
    • Fonts
    • SF Symbols
    • Icon Composer
    • Support

    Explore Support

    • Overview
    • Help Guides
    • Developer Forums
    • Feedback Assistant
    • Contact Us

    Featured

    • Account Help
    • App Review Guidelines
    • App Store Connect Help
    • Upcoming Requirements
    • Agreements and Guidelines
    • System Status
  • Quick Links

    • Events
    • News
    • Forums
    • Sample Code
    • Videos
 

Videos

Open Menu Close Menu
  • Collections
  • All Videos
  • About

Back to WWDC26

  • About
  • Summary
  • Transcript
  • Principles of great design

    Dive deep into fundamental design principles for Apple platforms.

    Chapters

    • 0:00 - Intro
    • 1:08 - Purpose
    • 1:52 - Agency
    • 3:38 - Responsibility
    • 6:04 - Familiarity
    • 8:52 - Flexibility
    • 11:13 - Simplicity
    • 13:42 - Craft
    • 15:47 - Delight

    Resources

    • Human Interface Guidelines: Design principles
      • HD Video
      • SD Video

    Related Videos

    WWDC26

    • Craft clear names for features and labels in your app

    WWDC17

    • Essential Design Principles
  • Search this video…

    Hi, I'm Linda. And I'm Doug. We're Design Evangelists at Apple.

    Let's start with a question: what is design? Take a second with it, because I think a lot of us, if we're being honest, would jump to "design is how something looks" or maybe even "design is how something behaves" And these definitions aren't necessarily incorrect, they just paint an incomplete picture. For us at Apple, design is making something with intention. It's focusing on what's most important to people, so you can build something they will truly value.

    Every feature you add to your product, asks something of the person using it. It asks for their time, their attention, and their trust. These are valuable things you can't afford to waste. So choosing what to build, is often a matter of deciding what not to include.

    Before you a draw a single sketch, or write a line of code, think about whether what you're making has purpose.

    Purpose, is one of the foundational principles, that you can use to design great experiences on Apple platforms. Experiences that serve people, that respect and adapt to their lives, that are clear and considered, and at their best, a genuine joy to use. Now, one thing we want to say upfront. There's no formula or right way, to combine these principles that guarantees you'll arrive at the perfect solution. You might even find that leaning into one principle, feels like you're compromising on another. But that's what makes design so interesting. Ultimately, it's up to you to use your knowledge and intuition to find the best path forward. Okay let's get into it! After purpose, there's agency.

    Agency is about putting people in control. People feel in control, when you let them do things their way.

    For example, do you want to take this next part? Oh, um, I'm okay, you can keep going! Okay! Offering choices is the best way to bring agency into your experience. An interface should never stand in the way of what someone is trying to do.

    Instead of guiding someone down a pre-determined path, let them dive right into your experience. And give them the autonomy to decide what to explore at their own pace.

    People are far more engaged when they have agency to control their own experience. Of course, that does mean people will make mistakes, or go down paths they didn't mean to.

    When that happens, offer forgiveness.

    People accidentally send, change, and delete things all the time.

    You can provide forgiveness by making it easy for them to undo any of their actions.

    And, when someone's about to do something destructive, double-check it's what they actually mean to do. In some cases, interruptions can be helpful. But use interruptions carefully, and only when someone is about to make a big mistake. Oops, I don't wanna do that! Just one sec here.

    Let's keep going.

    People really appreciate it, when you help them avoid disaster.

    Forgiveness supports agency because it gives people confidence that they can always recover from anything they try, and helps them feel capable, secure, and free to explore. Exactly. But when you give people freedom, you also have to protect their well-being.

    Which leads us to responsibility. On Apple platforms, responsibility means acting in people's best interest. And it starts with privacy. Privacy is a human right. And even though there's tons of information you can request from someone, it's not the best way to build a relationship. Imagine someone comes up to you like this: Hey! Hi! Give me your phone number.

    For what? I just need it.

    Uh, why? I'll tell you, once you give me your phone number.

    You wouldn't trust a person like that in real life. And yet, interfaces do this all the time.

    They throw permission prompts the second you launch them. Long before you've figured out what the app actually does.

    Or ask you for information, without providing context for what it's for.

    A responsible design treats people and their private information with respect, just like you would in the real world.

    Responsible interfaces wait for the right moment to ask for personal data. They only ask for what's necessary, and are transparent about the data is for.

    It's your responsibility to protect anyone using your product, and anyone who could be affected by it. That's why in addition to privacy, you should keep people safe.

    For interfaces, this means looking closely at what functionality you offer, and asking yourself some hard questions. How could this feature be misused? Who would be harmed by this? And how do I prevent it? Think about what it means to responsibly add AI capabilities to your product.

    When you build intelligent features, you have to anticipate that a model might generate something unexpected or inaccurate.

    Take something as innocent as a recipe app.

    If someone logs an allergy, you have to anticipate that the model may suggest an ingredient that could cause a severe reaction. That could do real-world harm and it's just something you can't leave to chance. Think realistically about what could go wrong, and add safeguards. Previews, confirmations, disclaimers can help, but consider removing features entirely, if the risks to people's safety outweigh the value. Ultimately, your work has a real impact on people's lives. So, when you take that responsibility seriously, it leads to a product people can trust.

    The next design principle, familiarity, is all about how people bring their existing knowledge to your design. Familiarity is about building on what people know.

    Your audience comes to you with a lifetime of experience. They understand how the real world works, and they've learned conventions from other interfaces. You can lean on that existing knowledge, to make your design intuitive.

    A great way to do this, is by using metaphor. Metaphors have been used since the earliest interfaces, to help people get familiar with software. What does this thing do? Same as the real world! Stuff I don't want, goes in the trash.

    And actually, if I made a mistake, I can retrieve it from the trash! Just like the real world! Okay! The trick to metaphors, is making sure they aren't too literal or abstract. In an interface, an inspector shows details of whatever is selected. If your inspector metaphor is too literal, people might not be familiar with what you're trying to show.

    If it's too abstract, you risk your idea not getting across.

    A good metaphor draws on something people know and helps people predict what it will do. When used correctly, metaphors instantly click. When used incorrectly, metaphors can be surprising, in a bad way.

    Let's go back to the trash can. If you use a trash can icon to mean something other than delete, it goes against people's familiarity with what this symbol represents, in other software.

    The same is true if you take creative liberty with the delete icon. People don't get that immediate recognition.

    For common actions, there's no need to reinvent the wheel. Just use the metaphors people are already familiar with, and make sure they do what people expect. Familiarity is also a product of being consistent. Consistency helps people predict what will happen next.

    Simply put, things that look the same should behave the same.

    If one of these buttons moves to a different screen, another toggles an action, and another pops up a modal, there's no pattern to understanding how this interface works.

    Consistent behavior helps people navigate your interface, because they can anticipate what will happen and where they're going. And so does consistent placement. On Mac, you can always close a window by going to the top left corner. It's always in the exact same spot.

    When someone can find an action in the same location across screens and devices, it speeds them up. They don't have to think about it.

    Creating something familiar is all about knowing which metaphors and patterns to use and when to use them. But familiarity doesn't mean recycling the same solution everywhere.

    That brings us to flexibility. A flexible design, recognizes a simple truth.

    That people use your design in ways as unique as they are. So support all the different contexts people find themselves in.

    Adding flexibility into your interface, allows it to adapt to people's actual lives. So, take listening to music.

    The way someone interacts with their music, changes completely depending on their context.

    They might be at home, controlling their music through the speakers.

    Or on a run with their AirPods and watch. Or driving, using a completely hands-free experience.

    An interface that accommodates different situations feels more comfortable and works for a wider audience. Right! And when you design for specific contexts, it shows you're paying attention to what a person wants to do.

    When someone pulls out their iPhone, they want quick, touch-based interactions. On Mac, they expect deep workflows, and precise pointer controls.

    Every device deserves a solution that takes advantage of what makes it unique.

    Of course, hardware is only half the story. The other half is the person using it. Another way make your design flexible, is to cater to the wide range of abilities people have.

    Get curious about who your audience is. How old are they? What languages do they speak? Are they a pro or a novice? Do they rely on accessibility features? You might not solve for every type of person on day one, but you can start examining how your experience can be more inclusive. Often, adding flexibility means you're not going to land on a single design solution that makes everyone happy. Sometimes, the best option, is to let people personalize your experience to suit their own preferences. Take something like controls. It's really hard to nail down a single layout that works perfectly for every person, so offer people the flexibility to rearrange them, to support their personal workflow. Or allow them to hide controls they never use.

    Flexibility is an investment, but it's worth it, because it proves to people that you designed with them in mind.

    Next, simplicity. Simplicity is about stripping away the unnecessary, so the core purpose of your design can shine.

    When we say simple, we don't mean minimal.

    If you bury all your functionality inside a single place, that might make your interface look more minimal, but it doesn't make it simple.

    Simple designs are frictionless and intuitive. People can find what they need without effort.

    And they get there by being concise and clear.

    Concise interfaces use plain language.

    They strip away jargon and speak naturally.

    They avoid redundancy and get straight to the point.

    Concise interfaces also respect people's time. They reduce the number of steps it takes to get things done. You can also achieve simplicity through being clear.

    A clear design perfectly communicates what it does.

    Clarity is built with hierarchy, using order, spacing, and contrast to guide people to what's most important.

    When your hierarchy is strong, the most important item on the screen is always the most obvious one.

    Clear interfaces answer people's questions: What do I pay attention to? What can I interact with? And how do I interact? In a simple interface, every element earns its place. So take a look at your design and identify where there's information you can distill down to its essence.

    Is there complex data that might be better understood as a graphic? Are there opportunities to summarize information so people can focus on what they care about? Make sure every element helps clarify your point. And in some cases, making an interface simpler can mean adding more to it.

    Take this video play/pause control. It's simple and familiar. I can pause what I'm watching, and when I come back to it later, I need more context. This control clarifies where I am and how much time is left. Sometimes, simple means adding context and information, so people can make informed decisions.

    Simple interfaces support the reason people are there. And you'll know you've arrived at simplicity when you have exactly enough! Our next principle is about executing what you have flawlessly.

    Craft is the attention to detail that tells people you really care about the experience you're giving them.

    We all know what a cheap product feels like. A rickety door that doesn't close properly. A shirt that unravels when you wash it. You can just tell when someone took shortcuts. And it's the same with software.

    You know exactly what it feels like to use an interface that was rushed out the door.

    You tap a button and you just have to wait for it do something. Scrolling is jittery. Icons are misaligned. You rotate your phone, and the layout gets all messed up. It feels fragile.

    When software feels thrown together, you question the quality of the results you'll get from using that product. But a meticulously crafted design does the exact opposite; it inspires confidence. So, what are the actual ingredients to a well-crafted design? Just like in the real world, it starts with high-quality materials.

    Beautiful fonts that look great across devices. Thoughtful colors that adapt seamlessly across light and dark environments.

    Clear graphics and iconography.

    Responsive animations that feel fluid and provide immediate, natural feedback.

    All built on a solid foundation of reliable and secure SDKs.

    These are the details that matter. But getting to that level of quality requires time. Craft comes from iteration and making sure every last piece of your interface functions beautifully. And this is a continual process.

    A large part of craft, is how you maintain your design over time.

    Great design has longevity, so keep evolving it. When new features or hardware are introduced, explore whether they make sense for your experience. When your product evolves with these changes, people feel supported and rewarded.

    Craft is an uncompromising commitment to the details. When you get those details right, people will know you care.

    Finally, delight. Delight is one of those things that's hard to define, but you instantly recognize it when you experience it.

    Delightful interfaces are satisfying, enriching, and create a real emotional connection.

    That connection starts when an experience feels human.

    The way to make a design delightful isn't by adding confetti or tacking on extra flourishes at the end of your process. You create a delightful interface by identifying the emotion you want your audience to feel. Relaxed, confident, excited, and finding opportunities to reinforce that through your design. Delight is the sum of the consideration you put into your product. It's the natural result of getting all the design principles right.

    Because when you design with intention and care... ...when you give people the agency to act, the safety to explore, the comfort of familiar patterns, and the ability to make it their own... ...you create an experience that's a true joy to use.

    And now it's your turn! The Human Interface Guidelines are the best resource to get started with designing for Apple platforms. And we've added a new design principles page, so you can learn more.

    Use these principles to guide your design, and go make something that people really love.

    • 0:00 - Intro
    • Design is more than aesthetics or behavior: it’s making something with intention. Every feature asks for a person’s time, attention, and trust, so choosing what not to build is just as important as what you do build.

    • 1:08 - Purpose
    • Purpose means designing experiences that genuinely serve people: ones that respect and adapt to their lives, are clear and considered, and at their best, a true joy to use. Before writing a line of code, ask whether what you’re making has real purpose and delivers something people will truly value.

    • 1:52 - Agency
    • Agency means putting people in control. Let them explore at their own pace, avoid forcing them down predetermined paths, and build in forgiveness: easy undo and confirmation for destructive actions, so they feel confident and free to try things.

    • 3:38 - Responsibility
    • Acting responsibly means respecting privacy as a human right, asking only for what’s necessary, and anticipating how features could cause harm. Safeguard people from bad outcomes, especially with AI, and remove features when the risks outweigh the value.

    • 6:04 - Familiarity
    • Familiarity lets people apply existing knowledge to your design. Use metaphors that aren’t too literal or abstract, follow established conventions for common actions, and keep behavior consistent: things that look the same should work the same.

    • 8:52 - Flexibility
    • A flexible design adapts to the many different contexts, devices, and abilities of its users. Design for each platform’s strengths, consider the full range of your audience, and let people personalize their experience when no single solution fits everyone.

    • 11:13 - Simplicity
    • Simplicity isn’t minimalism: it’s removing friction. Concise language, strong visual hierarchy, and clear affordances help people find what they need without effort. Every element should earn its place, and sometimes adding context makes an interface simpler.

    • 13:42 - Craft
    • Craft is the uncompromising attention to detail that builds trust. Beautiful typography, responsive animations, solid performance, and a commitment to iteration show people you care. Great design has longevity: keep evolving it as platforms and people’s needs change.

    • 15:47 - Delight
    • Delight isn’t confetti: it’s the natural result of getting everything else right. Identify the emotion you want people to feel, then reinforce it through your design. When you combine all these principles with genuine care, you create something people truly love.

Developer Footer

  • Videos
  • WWDC26
  • Principles of great design
  • Open Menu Close Menu
    • iOS
    • iPadOS
    • macOS
    • tvOS
    • visionOS
    • watchOS
    • App Store
    Open Menu Close Menu
    • Swift
    • SwiftUI
    • Swift Playground
    • TestFlight
    • Xcode
    • Xcode Cloud
    • Icon Composer
    • SF Symbols
    Open Menu Close Menu
    • Accessibility
    • Accessories
    • Apple Intelligence
    • Audio & Video
    • Augmented Reality
    • Business
    • Design
    • Distribution
    • Education
    • Games
    • Health & Fitness
    • In-App Purchase
    • Localization
    • Maps & Location
    • Machine Learning & AI
    • Security
    • Safari & Web
    Open Menu Close Menu
    • Documentation
    • Downloads
    • Sample Code
    • Videos
    Open Menu Close Menu
    • Help Guides & Articles
    • Contact Us
    • Forums
    • Feedback & Bug Reporting
    • System Status
    Open Menu Close Menu
    • Apple Developer
    • App Store Connect
    • Certificates, IDs, & Profiles
    • Feedback Assistant
    Open Menu Close Menu
    • Apple Developer Program
    • Apple Developer Enterprise Program
    • App Store Small Business Program
    • MFi Program
    • Mini Apps Partner Program
    • News Partner Program
    • Video Partner Program
    • Security Bounty Program
    • Security Research Device Program
    Open Menu Close Menu
    • Meet with Apple
    • Apple Developer Centers
    • App Store Awards
    • Apple Design Awards
    • Apple Developer Academies
    • WWDC
    Read the latest news.
    Get the Apple Developer app.
    Copyright © 2026 Apple Inc. All rights reserved.
    Terms of Use Privacy Policy Agreements and Guidelines