gap safari

New WebKit Features in Safari 14.1

Apr 29, 2021

by Jon Davis

Safari 14.1 for macOS Big Sur, iPadOS 14.5, and iOS 14.5 brings new WebKit features, APIs, performance improvements, and improved compatibility for web developers. Take a look.

Flexbox Gap Support

Safari 14.1 now supports the gap property inside Flexbox containers, along with row-gap and column-gap . Gaps in Flexbox make it possible for web developers to create space between Flex items without resorting to annoying margin hacks.

The gap property, of course, has worked inside Grid containers since Safari 12. Because gap is supported for Grid, testing support for the property in a Flexbox formatting context wasn’t possible by using feature queries ( @supports ). By adding support for gap in Flexbox, Safari brings the web closer to widespread compatibility.

For more information, see the “flex containers” definition in the “Row and Column Gutters” section of the CSS Box Alignment specification .

Date & Time Inputs on macOS

In HTML, the date , time , datetime-local attributes for the input element prompt the browser to create date and/or time controls — an interface that’s designed to let the user easily enter a time or a date, usually with a calendar. Safari has supported these input fields on iOS since 2012. Now with Safari 14.1, these fields are supported on macOS as well.

CSS Individual Transform Properties

With WebKit support of Individual Transform Properties, web developers can write CSS rules and keyframe animations in a more straightforward way.

For years , the transform property has provided the ability to scale, rotate, and translate. You could access this power through code like this:

Now, if you wish, you can instead write:

This is a syntactical and conceptual difference — the result is the same. You might find it easier to understand and remember.

This syntax also avoids unintentional overrides of other transform-related properties and eliminates pre-computing intermediate values when using keyframe animations.

You can learn more by reading “ CSS Individual Transform Properties ” on the WebKit blog.

Paint Timing API

A valuable metric to improving the performance of web content is the time it takes for the user-agent to show something to the user. WebKit added the Paint Timing API to its suite of performance APIs to provide this measurement. Developers can measure:

• first-paint for the time it takes to show pixels of anything that is not the user-agent’s default background
• first-contentful-paint to get the time for the user to see content such as text or an image

To learn more about the API, see the Paint Timing specification .

Web Speech API

The Web Speech API in WebKit has supported speech synthesis for some time. Now, Safari supports speech recognition powered by the same speech engine as Siri. That means web developers can enjoy the benefits of high-quality transcription for over 50 languages and dialects. Note that users will need Siri enabled in System Preferences on macOS or Settings in iOS or iPadOS for the API to be available to be used.

For more information on speech recognition and speech synthesis on the web, see the Web Speech API specification .

Web Audio API

As a continuing area of focus, Safari compatibility improvements are ongoing. Updates to the Web Audio API bring it to standards compliance. It is now available unprefixed with support for advanced audio processing via Audio Worklets.

You can learn more about web audio from the Web Audio API specification .

Interoperability Improvements

There are several new interoperability improvements in WebKit:

• Web Animations now work on 122 more properties
• Animation of pseudo-elements beyond ::before and ::after .
• Improved mouse support on iPadOS and in Catalyst apps, including wheel events and hover/pointer media queries

Updated wheel Event handling improves performance and interoperability with other browsers. Wheel handlers registered on root objects (window/document/body) with default arguments will be treated as passive. Pages that want to prevent the default handling of Wheel Events which result from gestures like trackpad swipes on macOS, must now call preventDefault() on the first Wheel Event in the sequence.

MediaRecorder API

WebKit added support for MediaStream Recording, also known as the MediaRecorder API. It allows websites to record audio and video, then encode them using the platform’s available set of default encodings.

Learn more in the MediaStream Recording specification .

WebM Support

WebKit added improved support for WebM media. With Safari 14, WebKit added support for WebM via MSE on iPadOS and macOS. Now, WebKit on macOS supports WebM files containing VP8 or VP9 video tracks and Vorbis audio tracks. Developers can now offer WebM content to users, though users will enjoy the best quality and power efficiency with h.264 or HEVC.

See the WebM Project for details.

JavaScript Improvements

Class fields.

Updates to the JavaScript engine in WebKit adds new support for private class fields to enforce restrictions for static and instance fields in ES6 classes. Developers that used conventions before can switch to built-in support to manage access to properties. Public static class fields are also available, adding to the previously supported public instance class fields.

To learn more, see the public and private instance field proposal .

Internationalization API

New Internationalization API features include Intl.DisplayNames , Intl.ListFormat , and Intl.Segmenter . Intl.DateTimeFormat was updated to support dateStyle and timeStyle options. The Intl.NumberFormat method was updated with support to display measurement units, notation formats, sign display, and narrow symbol currency formatting.

For more information on these formatting methods, see the proposals for Intl.DisplayNames , Intl.ListFormat , Intl.Segmenter , Intl.DateTimeFormat , and Intl.NumberFormat .

WeakRef and FinalizationRegistry

WeakRef supports holding an object that can be garbage collected when there are no strong references to it. The FinalizationRegistry object compliments WeakRef to manage cleanup tasks when a target object is garbage collected.

Read more details in the WeakRefs proposal .

WebAssembly

WebAssembly support, introduced with Safari 11 , is a low-level binary format used as a compilation target for existing languages.

WebAssembly support for the atomic instructions in the Threading specification, are enabled in Safari 14.1. Note, that until Safari supports the COEP/COOP headers, shared memory is not enabled as it could expose users to cross-origin Specter data leaks.

For more information, see the WebAssembly Specification for WASM Threads .

WebAssembly Sign Extension Operator

New sign-extension operator support preserves the number’s sign while extending the number of bits of an integer.

Learn more in the Sign-extension Ops proposal.

JavaScript BigInt Integration

Support for a new JavaScript API allows bidirectional conversion of a JavaScript BigInt value to a WASM 64-bit integer.

See the WebAssembly Specification for toJSValue .

Private Click Measurement

This release features Private Click Measurement – a proposed web standard that enables advertisers to measure the effectiveness of click-through ad campaigns in a privacy-preserving way. This new technology is part of a larger effort to remove cross-site tracking from the web and provide privacy-preserving alternatives where needed.

See “ Introducing Private Click Measurement, PCM ” on the WebKit blog.

Storage Access API Updates

WebKit has improved the Storage Access API to allow per-page storage access and allow nested iframes to request storage access. These interoperability changes are from the ongoing standardization of the Storage Access API together with Mozilla, Microsoft, and the web community. This API has shipped in Safari since 2018 and is part of a larger effort to remove cross-site tracking from the web and provide privacy-preserving alternatives where needed.

For details, see “ Updates to the Storage Access API ” on the WebKit blog.

Web Inspector Updates

The updates to Web Inspector available in these releases include:

• A new three-panel layout in the Elements Tab brings the Styles sidebar into an independent panel alongside the existing details sidebar.
• The new Font panel gives content authors visibility into details of the fonts used on the page.
• Breakpoints in the Sources Tab can now be configured with conditions or actions, reducing the need for stray console.log statements left in production code.

To learn more about Web Inspector features, see the Web Inspector Reference documentation.

Availability

These improvements are available to users running Safari on iPadOS 14.5, iOS 14.5, or Safari 14.1 on macOS Big Sur (11.3), macOS Catalina, or macOS Mojave. These features were also available to web developers in Safari Technology Preview releases. Changes in this release of Safari were included in the following Safari Technology Preview releases: 110 , 111 , 112 , 113 , 114 , 115 , 116 , 117 , 118 , 119 , 120 , 121 , 122 .

Download the latest Safari Technology Preview release to stay at the forefront of future web platform and Web Inspector features. You can also use the WebKit Feature Status page to watch for changes to web platform features you’re interested in.

If you run into any issues, we welcome your bug reports for Safari or WebKit bugs for web content issues. Send us a tweet @webkit to share your thoughts on this release.

Polyfilling Flex Gap

gap is a very useful CSS property that allows to set separation or glutter between children elements in a layout.

gap is a shorthand to set row-gap (vertical gap) and column-gap (horizontal gap) in one declaration.

Unfortunately, gap global support is not very complete, specially in Safari. At the time of this writing, it has 71.56% support due primarily to lack of support in Safari (it started supporting gap for flex containers since iOS 14.5 launched on April 26, 2021).

Important: gap support for flexbox containers is lower than on grid containers, which has a global support of 92.9%

Depending on our target users, they may use old browsers. If you check your website usage and notice that an important part of your users use browsers that don't play well with the gap property on flexbox, you may need to use a polyfill instead.

Simulating Flex Gap

Let's start with the following markup:

We build a container with 8 children. I've ommited styling classes to keep it simple.

Here's the class of the container:

We defined a flex container that allows elements to wrap.

This produces a grid-like view of four elements per row as shown below:

Now, let's try to add a separation between each item within the container. Let's try to add margin between elements by using the Adjacent Sibling Combinator (* + *) :

Here's how it looks:

It doesn't work because when items span more than one column, from the second item on, there's extra margin to the left. This is because we're applying margin to every children that follows another children. You can read more about the Adjacent Sibling Combinator here .

To fix the issue with the extra margin at the left and top, we can add negative margins to the parent like this:

Now our layout looks as expected:

Now that we have a working layout with gaps, here's how our code looks like:

You can customize the margins whenever you want to simulate row-gap and column-gap using CSS properties :

You can't add border that surrounds the content because inner elements have a margin applied to the left.

Since we use margins on both the parent and children elements, if we try to have multiple levels of nesting involving our solution, it won't work because we're trying to modify the margin between elements. Below is an example on this that shows how a little margin is added to the elements.

If you can use gap , go ahead and do it. Your code will be easier to manage and less error-prone. If you can't, make sure that you apply a polyfill that is easy to change in the future so you can evaluate it again in, let's say 1 year or whatever makes sense to you!

The curious case of flexbox gap and Safari

• 28 Apr 2021

Update at the end

The gap property was first introduced to add inner grid spacing but was extended in the spec to work with flexbox. With one line of code, you can replace something like this:

That’s nice, but Safari doesn’t support gap in flexbox just yet. Normally I’d just reach for @supports :

Unfortunately, Safari already supports gap in grid , so this doesn’t work. This is one of those weird cases where there is no easy CSS-only solution, though there have been proposals for workarounds .

This has left me scratching my head. You could polyfill with JavaScript or use PostCSS , but at this point, is it worth it? That’s a question that all frontend developers have to weigh from time to time, and there’s no one-size-fits-all answer.

I will probably wait until Safari supports flexbox gap in the latest two versions before using it, mainly because it doesn’t take that much more CSS to achieve the same effect. The only drawback is I cannot change the margins of the flex container. This can be overcome with an extra wrapper element, but then you’re starting to complicate the markup.

If you want to read more about the flexbox gap issue, check out this post from Ahmad Shadeed . And if you found this post helpful, please like it on Dev Community and let me know on Twitter .

Until tomorrow!

As of Safari 14.1, flex gap is now supported ! This brings me one step closer to replacing my object styles that do the same thing. I typically wait until something is supported in the last two versions of the evergreen browsers (or can be worked around).

I would still love to have a way to use @supports , but I’ll take what I can get. Anyway, happy coding!

DigitalOcean provides cloud products for every stage of your journey. Get started with $200 in free credit!

The gap property in CSS is a shorthand for row-gap and column-gap , specifying the size of gutters, which is the space between rows and columns within grid , flex , and multi-column layouts.

Use the slider in the demo below to see the gap property in action:

gap accepts one or two values:

• A single value sets both row-gap and column-gap by the same value.
• When two values are used, the first sets the row-gap and the second sets the column-gap .

The specification for the CSS Grid Layout Module defined the space between grid tracks using the grid-gap property. gap is intended to replace it so that gaps can be defined in multiple CSS layout methods, like flexbox, but grid-gap still needs to be used in instances where a browser may have implemented grid-gap but has yet to start supporting the newer gap property.

gap accepts the following values:

• normal : (Default) The browser will specify a used value of 1em for multi-column layout and 0px for all other layout contexts (i.e. grid and flex).
• <length> : Any valid and non-negative CSS length, such as px , em , rem and % , among others.
• <percentage> : The size of the gap as a non-negative percentage value relative to the dimension of the element. (See below for details.)
• initial : Applies the property’s default setting, which is normal .
• inherit : Adopts the gap value of the parent.
• unset : Removes the current gap from the element.

Percentages in gap properties

When the size of a container in the gap dimension is definite, gap resolves percentages against the size of the container’s content box in any layout types.

In other words, when the browser knows the size of the container, it can calculate the percentage value of the gap . For example, when the container’s height is 100px and the gap is set to 10%, browser knows that 10% of 100px is 10px.

But when the browser doesn’t know the size, it will wonder, “10% of what?” In these cases, gap behaves differently based on the layout type.

In a grid layout, percentages resolve against zero for determining intrinsic size contributions, but resolve against the element’s content box when laying out the box’s contents, meaning it will put space between items but the space doesn’t affect the container’s size.

In this demo, the container’s height is not definite. See what happens when you increase the gap size. Then set the gap in pixel units and try again:

In a flex layout, percentages resolve against zero in all cases, meaning that gaps will not apply when the size of the container is not known to the browser:

Using the calc() function with gap

You can use calc() function to specify the size of the gap but, at the time of this writing, there is no support for it on Safari and iOS.

The gap property is designed for use in grid, flex and multi-column layouts. Let’s check out some examples.

Grid layout

In the following demo, you can see gap being used to specify the row-gap and column-gap properties on a grid container, defining the gutters between grid rows and grid columns, respectively:

Flex layout

Applying gap to the main axis of a flex container indicates spacing between flex items in a single line of the flex layout.

Here’s column-gap used in a row direction:

Here’s row-gap used in a column direction:

Applying gap to the cross axis of a flex container indicates spacing between flex lines of the flex layout.

Here’s row-gap in a row direction:

Here’s column-gap in a column direction:

Multi-column layout

column-gap appears in multi-column layouts to create gaps between column boxes, but note that row-gap has no effect since we’re only working in columns. gap can still be used in this context, but only the column-gap will be applied.

As you can see in the next demo, although the gap property has a value of 2rem, it’s only separating items horizontally instead of both directions since we’re working in columns:

The more you know…

There are a couple of things worth noting about working with the gap property.

It’s a nice way to prevent unwanted spacing

Have you ever used margins to create spacing between elements? If we’re not careful, we can end up with extra spacing before and after the group of items.

Solving that usually requires adding negative margins or resorting to pseudo-selectors to remove margin from specific items. But the nice thing about using gap in more modern layout methods is that you only have space between items. The extra cruft at the start and end is never an issue!

But, hey, if you want to have space around the items while using gap , put padding around the container like this:

Gutter size is not always equal to the gap value

The gap property is not the only thing that can put space between items. Margins, paddings, justify-content and align-content can also increase the size of the gutter and affect the actual gap value.

In the following example, we’re setting a 1em gap but, as you can see, there is much more space between the items, caused by the use of distributed alignments, like justify-content and align-content :

Browser support

Feature queries are usually a nice way to check if a browser supports a specific property, but in this case, if you check for the gap property in flexbox, you may get a false positive because a feature query won’t distinguish between layout modes. In other words, it might be supported in a flex layout which results in a positive result, but it is actually not supported if it’s used in a grid layout.

Grid layout with calc() values

Grid layout with percentage value.

The specification for using gap with flexbox is currently in Working Draft status.

This browser support data is from Caniuse , which has more detail. A number indicates that browser supports the feature at that version and up.

Mobile / Tablet

More information.

• CSS Box Alignment Module Level 3
• Chromium lands Flexbox gap (Ticket #761904 )
• WebKit CSS Feature Status
• Grid Layout
• Flexbox Layout
• Multi-Column Layout
• CSS Grid Layout: An Introduction (Alligator.io)

grid-row / grid-column

Navigation Menu

Search code, repositories, users, issues, pull requests..., provide feedback.

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly.

To see all available qualifiers, see our documentation .

• Notifications You must be signed in to change notification settings

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement . We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

gap doesn't work with flex on Safari #12452

ludwiczakpawel commented Jan 27, 2021

github-actions bot commented Jan 27, 2021

Sorry, something went wrong.

danieltott commented Feb 2, 2021

Ludwiczakpawel commented feb 2, 2021 • edited loading.

• 🚀 1 reaction

ludwiczakpawel commented Feb 2, 2021

• 👍 2 reactions
• 🎉 1 reaction

danieltott commented Feb 11, 2021

• 🎉 2 reactions

doublejosh commented Nov 30, 2021

• 😕 4 reactions
• 👀 1 reaction

Successfully merging a pull request may close this issue.

• Kenya Safaris
• Tanzania Safaris
• Uganda Safaris
• Special Offers

Jambo na Karibu - Kenya Hakuna Matata!

Gap safaris is one of the best tour operators in kenya. we organize diversified kenyan and east african safaris with great satisfaction and value. situated in ukunda, on kenya's south coast, we are just a few meters from the shores and the sands of the world-famous diani beach. our aim is to satisfy every discerning traveler by making their dreams come true and leaving long-lasting memories of the african experience.  ,  gap safaris special offers,  why travel gap safaris , gap safaris is ready to take you to the untouched world, and we assure you of the most memorable safari of your lifetime. we will take you through vast, breathtaking wildlife and show you the different cultures in east africa, just to add to your full satisfaction., gap safaris destinations.

• Skip to main content
• Skip to search
• Skip to select language
• Sign up for free
• Português (do Brasil)

The gap CSS shorthand property sets the gaps (also called gutters ) between rows and columns. This property applies to multi-column , flex , and grid containers.

Constituent properties

This property is a shorthand for the following CSS properties:

This property is specified as a value for <'row-gap'> , followed optionally by a value for <'column-gap'> . If <'column-gap'> is omitted, it is set to the same value as <'row-gap'> . Both <'row-gap'> and <'column-gap'> can each be specified as a <length> or a <percentage> .

Specifies the width of the gutter separating columns, flex items , flex lines, and grid lines .

Specifies the width of the gutter separating columns, flex items, flex lines, and grid lines relative to the dimension of the element.

Description

This property defines gaps between columns in CSS multi-column layout , between flex items and flex lines in CSS flexible box layout , and between rows and columns in CSS grid layout .

The generated gaps create empty spaces that have the width or height of the gap's specified size, much like an empty item or track. The visible space between elements may differ from the provided gap value because margins, padding, and distributed alignment may increase the separation between elements beyond what is determined by gap .

In grid layout, the first value defines the gutter between rows, and the second defines the gutter between columns. In both grid and flex layouts, if only one value is included, that value is used for both dimensions.

With flex containers, whether the first value is the gap between flex items or between flex lines depends on the direction. Flex items are laid out in either rows or columns depending on the value of the flex-direction property. For rows ( row (the default) or row-reverse ), the first value defines the gap between flex lines, and the second value defines the gap between items within each line. For columns ( column or column-reverse ), the first value defines the gap between flex items within a flex line, and the second value defines the gaps between each flex line.

In multi-column containers, the first value defines the gap between columns. A dividing line can be added to the otherwise "empty space" by using the column-rule-style property or column-rule shorthand.

Percentage gap values are always calculated against the content box size of the container element. The behavior is well-defined and consistent across layout modes when the container size is definite. As these three layout modes (multi-column, flex, and grid) treat cyclic percentage sizes differently, gap also does so. In grid layout, cyclic percentage sizes resolve against zero for determining intrinsic size contributions but resolve against the element's content box when laying out the contents. Two examples below demonstrate percentage gap values with explicit container size and implicit container size in the examples section.

Early versions of the specification called this property grid-gap , and to maintain compatibility with legacy websites, browsers still accept grid-gap as an alias for gap .

Formal definition

Formal syntax, flex layout, grid layout, multi-column layout, percentage gap value and explicit container size.

If the container has a fixed size set, then gap percentage value calculations are based on the size of the container. Thus, gap behavior is consistent across all layouts. In the following example, there are two containers, one with a grid layout and the other with a flex layout. The containers have five red 20x20px children. Both containers are explicitly set to 200px high using height: 200px and the gap is set with gap: 12.5% 0 .

Now inspect the grid and flex elements using Inspector tab in Web Developer Tools . In order to see the actual gaps hover mouse over <div id="grid"> and <div id="flex"> tags in the inspector. You will notice that the gap is the same in both cases which is 25px.

Percentage gap value and implicit container size

If size is not explicitly set on the container, then the percentage gap behaves differently in case of grid and flex layouts. In the following example the containers don't have height explicitly set.

In case of the grid layout, percentage gap doesn't contribute to the actual height of the grid. The container's height is calculated using 0px gap, so the actual height turns out to be 100px (20px x 5). Then the actual percentage gap is calculated using the content box's height, the gap turns out to be 12.5px (100px x 12.5%). The gap is applied just before rendering. Thus the grid remains 100px high but it overflows due to the percentage gap added later just before rendering.

In case of the flex layout, the percentage gap always results in zero value.

Specifications

Browser compatibility.

BCD tables only load in the browser with JavaScript enabled. Enable JavaScript to view data.

• Basic concepts of grid layout: gutters
• CSS box alignment module
• CSS flexible box layout module
• CSS grid layout module
• CSS multi-column layout module

gap property for Flexbox

`gap` for flexbox containers to create gaps/gutters between flex items

CSS3 Multiple column layout

Method of flowing information in multiple columns

fontface api: linegapoverride

Css at-rule: `@font-face`: line-gap-override, css property: column-gap, css property: column-gap: supported in flex layout, css property: column-gap: supported in grid layout, css property: column-gap: supported in multi-column layout, css property: column-gap: supported in multi-column layout: `calc()` values, css property: column-gap: supported in multi-column layout: `<percentage>` values, css property: gap, css property: gap: supported in flex layout, css property: gap: supported in grid layout, css property: gap: supported in grid layout: `calc()` values, css property: gap: supported in grid layout: `<percentage>` values, css property: gap: supported in multi-column layout, css property: row-gap, css property: row-gap: supported in flex layout, css property: row-gap: supported in grid layout.

How it works

For Business

Join Mind Tools

Article • 9 min read

The MoSCoW Method

Understanding project priorities.

Written by the Mind Tools Content Team

(Also Known As MoSCoW Prioritization and MoSCoW Analysis)

You probably use some form of prioritized To-Do List to manage your daily tasks. But what happens when you're heading up a project that has various stakeholders, each of whom has a different opinion about the importance of different requirements? How do you identify the priority of each task, and communicate that to team members, stakeholders and customers alike?

This is when it's useful to apply a prioritizing tool such as the MoSCoW method. This simple project-management approach helps you, your team, and your stakeholders agree which tasks are critical to a project's success. It also highlights those tasks that can be abandoned if deadlines or resources are threatened.

In this article, we'll examine how you can use the MoSCoW method to prioritize project tasks more efficiently, and ensure that everyone expects the same things.

What Is the MoSCoW Method?

The MoSCoW method was developed by Dai Clegg of Oracle® UK Consulting in the mid-1990s. It's a useful approach for sorting project tasks into critical and non-critical categories.

MoSCoW stands for:

• Must – "Must" requirements are essential to the project's success, and are non-negotiable. If these tasks are missing or incomplete, the project is deemed a failure.
• Should – "Should" items are critical, high-priority tasks that you should complete whenever possible. These are highly important, but can be delivered in a second phase of the project if absolutely necessary.
• Could – "Could" jobs are highly desirable but you can leave them out if there are time or resource constraints.
• Would (or "Won't") – These tasks are desirable (for example, "Would like to have…") but aren't included in this project. You can also use this category for the least critical activities.

The "o"s in MoSCoW are just there to make the acronym pronounceable.

Terms from Clegg, D. and Barker, R. (1994). ' CASE Method Fast-Track: A RAD Approach ,' Amsterdam: Addison-Wesley, 1994. Copyright © Pearson Education Limited. Reproduced with permission.

People often use the MoSCoW method in Agile Project Management . However, you can apply it to any type of project.

MoSCoW helps you manage the scope of your project so that it isn't overwhelmingly large. It is particularly useful when you're working with multiple stakeholders, because it helps everyone agree on what's critical and what is not. The four clearly labeled categories allow people to understand a task's priority easily, which eliminates confusion, misunderstanding, conflict, and disappointment.

For example, some project management tools sort tasks into "high-," "medium-," and "low-" priority categories. But members of the team might have different opinions about what each of these groupings means. And all too often, tasks are labeled "high" priority because everything seems important. This can put a strain on time and resources, and ultimately lead to the project failing.

Using the MoSCoW Method

Follow the steps below to get the most from the MoSCoW method. (This describes using MoSCoW in a conventional "waterfall" project, however the approach is similar with agile projects.)

Step 1: Organize Your Project

It's important that you and your team fully understand your objectives before starting the project.

Write a business case to define your project's goals, its scope and timeline, and exactly what you will deliver. You can also draw up a project charter to plan how you'll approach it.

Next, conduct a stakeholder analysis to identify key people who are involved in the project and to understand how its success will benefit each of them.

Step 2: Write out Your Task List

Once you understand your project's objectives, carry out a Gap Analysis to identify what needs to happen for you to meet your goals.

Step 3: Prioritize Your Task List

Next, work with your stakeholders to prioritize these tasks into the four MoSCoW categories: Must, Should, Could, and Would (or Won't). These conversations can often be "difficult," so brush up on your conflict resolution, group decision making and negotiating skills beforehand!

Rather than starting with all tasks in the Must category and then demoting some of them, it can be helpful to put every task in the Would category first, and then discuss why individual ones deserve to move up the list.

Step 4: Challenge the MoSCoW List

Once you've assigned tasks to the MoSCoW categories, critically challenge each classification.

Be particularly vigilant about which items make it to the Must list. Remember, it is reserved solely for tasks that would result in the project failing if they're not done.

Aim to keep the Must list below 60 percent of the team's available time and effort. The fewer items you have, the higher your chance of success.

Try to reach consensus with everyone in the group. If you can't, you then need to bring in a key decision-maker who has the final say.

Step 5: Communicate Deliverables

Your last step is to share the prioritized list with team members, key stakeholders and customers.

It's important that you communicate the reasons for each categorization, particularly with Must items. Encourage people to discuss any concerns until people fully understand the reasoning.

Zhen is a project manager for a large IT organization. She's working with a team of designers, marketers and developers to redesign a large corporate client's website.

At the initial meeting, each group has strong opinions about which tasks are most important to the project's success, and no one wants to give up their "high priority" objective.

For example, the marketing team is adamant that the new website should gather visitors' personal information, for use in future marketing campaigns.

Meanwhile, the designers are arguing that, while this is important, the site may be more successful if it had a professionally produced streaming video. They also want a feed streaming onto the website's home page from the client's social networking accounts.

The developers counter that the current prototype design won't translate well onto mobile devices, so the top priority is retrofitting the site so people can view it on these.

Zhen can see that, while each priority is important, they're not all critical to the project's success. She decides to use the MoSCoW method to help the group reach consensus on which task is truly "mission critical."

She starts with a key question: "If I came to you the night before rollout and the following task was not done, would you cancel the project?" This question helped everyone in the group drill down to the project's most important priority.

The group finally agreed on the following priorities:

• Must – The retrofit website must be easily viewable on mobile devices.
• Should – There should be a social networking stream included.
• Could – There could be a streaming video on the site to help users.
• Would – Personal information would be gathered for future marketing efforts, but not on this occasion.

The MoSCoW method helped everyone agree on what was truly important for the project's final success.

The MoSCoW method is a simple and highly useful approach that enables you to prioritize project tasks as critical and non-critical. MoSCoW stands for:

• Must – These are tasks that you must complete for the project to be considered a success.
• Should – These are critical activities that are less urgent than Must tasks.
• Could – These items can be taken off the list if time or resources are limited.
• Would – These are tasks that would be nice to have, but can be done at a later date.

The benefit of the MoSCoW approach is that it makes it easy for team members and key stakeholders to understand how important a task is for a project's success.

Apply This to Your Life

Try using the MoSCoW method to prioritize your daily tasks. Look at what you completed at the end of the day. Did prioritizing enable you to get more done?

You've accessed 1 of your 2 free resources.

Get unlimited access

Discover more content

How to use burndown charts.

Keeping Your Projects on Track

Turn Your Idea Into Reality

Getting Good Ideas Off the Drawing Board

Add comment

Comments (0)

Be the first to comment!

Get set for career success – with 50% off

As September is a peak hiring season, we’re offering 50% off an annual Mind Tools subscription to help you hone your expertise.

Sign-up to our newsletter

Subscribing to the Mind Tools newsletter will keep you up-to-date with our latest updates and newest resources.

Subscribe now

Business Skills

Personal Development

Leadership and Management

Member Extras

Most Popular

Latest Updates

What Are Your Values?

The Change Curve

Mind Tools Store

About Mind Tools Content

Discover something new today

Getting to the Root of a Problem Quickly

Force Field Analysis

Analyzing the Pressures For and Against Change

How Emotionally Intelligent Are You?

Boosting Your People Skills

Self-Assessment

What's Your Leadership Style?

Learn About the Strengths and Weaknesses of the Way You Like to Lead

Recommended for you

Making small talk.

Taking the Complexity Out of Simple Conversations

Business Operations and Process Management

Strategy Tools

Customer Service

Business Ethics and Values

Handling Information and Data

Project Management

Knowledge Management

Self-Development and Goal Setting

Time Management

Presentation Skills

Learning Skills

Career Skills

Communication Skills

Negotiation, Persuasion and Influence

Working With Others

Difficult Conversations

Creativity Tools

Self-Management

Work-Life Balance

Stress Management and Wellbeing

Coaching and Mentoring

Change Management

Team Management

Managing Conflict

Delegation and Empowerment

Performance Management

Leadership Skills

Developing Your Team

Talent Management

Problem Solving

Decision Making

Member Podcast

Member Newsletter

• Integrations
• Learning Center

MoSCoW Prioritization

What is moscow prioritization.

MoSCoW prioritization, also known as the MoSCoW method or MoSCoW analysis, is a popular prioritization technique for managing requirements. 

  The acronym MoSCoW represents four categories of initiatives: must-have, should-have, could-have, and won’t-have, or will not have right now. Some companies also use the “W” in MoSCoW to mean “wish.”

What is the History of the MoSCoW Method?

Software development expert Dai Clegg created the MoSCoW method while working at Oracle. He designed the framework to help his team prioritize tasks during development work on product releases.

You can find a detailed account of using MoSCoW prioritization in the Dynamic System Development Method (DSDM) handbook . But because MoSCoW can prioritize tasks within any time-boxed project, teams have adapted the method for a broad range of uses.

How Does MoSCoW Prioritization Work?

Before running a MoSCoW analysis, a few things need to happen. First, key stakeholders and the product team need to get aligned on objectives and prioritization factors. Then, all participants must agree on which initiatives to prioritize.

At this point, your team should also discuss how they will settle any disagreements in prioritization. If you can establish how to resolve disputes before they come up, you can help prevent those disagreements from holding up progress.

Finally, you’ll also want to reach a consensus on what percentage of resources you’d like to allocate to each category.

With the groundwork complete, you may begin determining which category is most appropriate for each initiative. But, first, let’s further break down each category in the MoSCoW method.

Start prioritizing your roadmap

Moscow prioritization categories.

1. Must-have initiatives

As the name suggests, this category consists of initiatives that are “musts” for your team. They represent non-negotiable needs for the project, product, or release in question. For example, if you’re releasing a healthcare application, a must-have initiative may be security functionalities that help maintain compliance.

The “must-have” category requires the team to complete a mandatory task. If you’re unsure about whether something belongs in this category, ask yourself the following.

If the product won’t work without an initiative, or the release becomes useless without it, the initiative is most likely a “must-have.”

2. Should-have initiatives

Should-have initiatives are just a step below must-haves. They are essential to the product, project, or release, but they are not vital. If left out, the product or project still functions. However, the initiatives may add significant value.

“Should-have” initiatives are different from “must-have” initiatives in that they can get scheduled for a future release without impacting the current one. For example, performance improvements, minor bug fixes, or new functionality may be “should-have” initiatives. Without them, the product still works.

3. Could-have initiatives

Another way of describing “could-have” initiatives is nice-to-haves. “Could-have” initiatives are not necessary to the core function of the product. However, compared with “should-have” initiatives, they have a much smaller impact on the outcome if left out.

So, initiatives placed in the “could-have” category are often the first to be deprioritized if a project in the “should-have” or “must-have” category ends up larger than expected.

4. Will not have (this time)

One benefit of the MoSCoW method is that it places several initiatives in the “will-not-have” category. The category can manage expectations about what the team will not include in a specific release (or another timeframe you’re prioritizing).

Placing initiatives in the “will-not-have” category is one way to help prevent scope creep . If initiatives are in this category, the team knows they are not a priority for this specific time frame. 

Some initiatives in the “will-not-have” group will be prioritized in the future, while others are not likely to happen. Some teams decide to differentiate between those by creating a subcategory within this group.

How Can Development Teams Use MoSCoW?

  Although Dai Clegg developed the approach to help prioritize tasks around his team’s limited time, the MoSCoW method also works when a development team faces limitations other than time. For example: 

Prioritize based on budgetary constraints.

What if a development team’s limiting factor is not a deadline but a tight budget imposed by the company? Working with the product managers, the team can use MoSCoW first to decide on the initiatives that represent must-haves and the should-haves. Then, using the development department’s budget as the guide, the team can figure out which items they can complete. 

Prioritize based on the team’s skillsets.

A cross-functional product team might also find itself constrained by the experience and expertise of its developers. If the product roadmap calls for functionality the team does not have the skills to build, this limiting factor will play into scoring those items in their MoSCoW analysis.

Prioritize based on competing needs at the company.

Cross-functional teams can also find themselves constrained by other company priorities. The team wants to make progress on a new product release, but the executive staff has created tight deadlines for further releases in the same timeframe. In this case, the team can use MoSCoW to determine which aspects of their desired release represent must-haves and temporarily backlog everything else.

What Are the Drawbacks of MoSCoW Prioritization?

  Although many product and development teams have prioritized MoSCoW, the approach has potential pitfalls. Here are a few examples.

1. An inconsistent scoring process can lead to tasks placed in the wrong categories.

  One common criticism against MoSCoW is that it does not include an objective methodology for ranking initiatives against each other. Your team will need to bring this methodology to your analysis. The MoSCoW approach works only to ensure that your team applies a consistent scoring system for all initiatives.

Pro tip: One proven method is weighted scoring, where your team measures each initiative on your backlog against a standard set of cost and benefit criteria. You can use the weighted scoring approach in ProductPlan’s roadmap app .

2. Not including all relevant stakeholders can lead to items placed in the wrong categories.

To know which of your team’s initiatives represent must-haves for your product and which are merely should-haves, you will need as much context as possible.

For example, you might need someone from your sales team to let you know how important (or unimportant) prospective buyers view a proposed new feature.

One pitfall of the MoSCoW method is that you could make poor decisions about where to slot each initiative unless your team receives input from all relevant stakeholders. 

3. Team bias for (or against) initiatives can undermine MoSCoW’s effectiveness.

Because MoSCoW does not include an objective scoring method, your team members can fall victim to their own opinions about certain initiatives. 

One risk of using MoSCoW prioritization is that a team can mistakenly think MoSCoW itself represents an objective way of measuring the items on their list. They discuss an initiative, agree that it is a “should have,” and move on to the next.

But your team will also need an objective and consistent framework for ranking all initiatives. That is the only way to minimize your team’s biases in favor of items or against them.

When Do You Use the MoSCoW Method for Prioritization?

MoSCoW prioritization is effective for teams that want to include representatives from the whole organization in their process. You can capture a broader perspective by involving participants from various functional departments.

Another reason you may want to use MoSCoW prioritization is it allows your team to determine how much effort goes into each category. Therefore, you can ensure you’re delivering a good variety of initiatives in each release.

What Are Best Practices for Using MoSCoW Prioritization?

If you’re considering giving MoSCoW prioritization a try, here are a few steps to keep in mind. Incorporating these into your process will help your team gain more value from the MoSCoW method.

1. Choose an objective ranking or scoring system.

Remember, MoSCoW helps your team group items into the appropriate buckets—from must-have items down to your longer-term wish list. But MoSCoW itself doesn’t help you determine which item belongs in which category.

You will need a separate ranking methodology. You can choose from many, such as:

• Weighted scoring
• Value vs. complexity
• Buy-a-feature
• Opportunity scoring

For help finding the best scoring methodology for your team, check out ProductPlan’s article: 7 strategies to choose the best features for your product .

2. Seek input from all key stakeholders.

To make sure you’re placing each initiative into the right bucket—must-have, should-have, could-have, or won’t-have—your team needs context. 

At the beginning of your MoSCoW method, your team should consider which stakeholders can provide valuable context and insights. Sales? Customer success? The executive staff? Product managers in another area of your business? Include them in your initiative scoring process if you think they can help you see opportunities or threats your team might miss. 

3. Share your MoSCoW process across your organization.

MoSCoW gives your team a tangible way to show your organization prioritizing initiatives for your products or projects. 

The method can help you build company-wide consensus for your work, or at least help you show stakeholders why you made the decisions you did.

Communicating your team’s prioritization strategy also helps you set expectations across the business. When they see your methodology for choosing one initiative over another, stakeholders in other departments will understand that your team has thought through and weighed all decisions you’ve made. 

If any stakeholders have an issue with one of your decisions, they will understand that they can’t simply complain—they’ll need to present you with evidence to alter your course of action.  

Related Terms

2×2 prioritization matrix / Eisenhower matrix / DACI decision-making framework / ICE scoring model / RICE scoring model

Prioritizing your roadmap using our guide

Talk to an expert.

Schedule a few minutes with us to share more about your product roadmapping goals and we'll tailor a demo to show you how easy it is to build strategic roadmaps, align behind customer needs, prioritize, and measure success.

Share on Mastodon