web design Rockland Massachusetts

Rockland website builder

web design description

Hello and welcome to this website builder Web Designer Rockland video tutorial.

I’m Owen Corso from Google.

web design banner web design xampp

And today, we’re going to build a rich media expandable creative with video.

Let’s start by selecting file, New File.

This opens a dialog box where we will set up our ad.

First, let’s make out high of project.

We have four options– The default is Display & Video 360so we will leave that as is.

web design description

Dynamic Exits in Studio - Google Web Designer

As part of Intuit’s core initiatives to further cultivate mobile first thinking and accelerate growth into global markets, the Intuit Small Business Group’s Design Org has shifted from a model of designing and shipping prioritized features to a model where every designer is responsible for end-to-end, cross-device experiences, which includes designing for our products and services on desktop web, mobile web, desktop client apps, and native mobile apps.

As a design lead for our ecosystem of native mobile products over the past few years, I started getting a lot of questions around guidance and principles for mobile design. I noticed many of the designers, product managers, and engineers who are new to mobile app design or don’t live and breathe mobile app development on an everyday basis didn’t fully understand the nature of designing for native platforms and device capabilities. To reinforce the notion that “cross-device” and “mobile first” isn’t just about designing for smaller screens and scaling across multiple device sizes, I collaborated with the Design Systems Team to establish a set of mobile patterns and guidelines so that designers can hit the ground running, or run even faster, with mobile design. We recently published some guidelines, tools, and resources on our internal design toolkit that I thought would be great to share some key points and takeaways with a wider audience as the documentation addresses many frequently asked questions around mobile patterns.

Firstly, I want to start off by saying that what I write here is simply for guidance. Our mantra for any kind of pattern guidelines documentation we provide is, “Give me guidance, but let me drive.” We don’t want to be prescriptive, and we don’t want to tell you how to design, but this is a good starting point to get you going on native mobile designs. Why are we calling out native mobile? As we continue to design device-agnostic, end-to-end experiences and features for products and services, we must remember not to neglect the different platforms (i.e. our mobile products are currently offered on both iOS and Android).

Overall Principles

1. Respect the platform

We documented patterns and components based on native operating systems that we have apps on: iOS and Android. When designing for native platforms, you should consistently refer to the native OS design guidelines first for maximum quality. Keep in mind that native platform guidelines constantly evolve, so it’s always good practice to stay on top of these guidelines and refresh your memory and knowledge often.

Apple’s Human Interface Guidelines: https://developer.apple.com/ios/human-interface-guidelines/

Google’s Material Design Guidelines: https://material.io/guidelines/

2. Focus on the customer benefit

Always design for the customer benefit first. No use case is the same, and many use cases have exceptions. Do not design something simply because you can reuse a pattern or component for another feature. Design patterns help ground us as a system and unify an experience across an ecosystem of products, but they should by no means be the first or last stop in the design process. Always question yourself: How will this benefit the customer?

3. Think device first

Push your thinking beyond “mobile first.” Start thinking about leveraging device capabilities first. The native mobile device has a lot to offer: touch, voice, pressure, location tracking, accelerometer, notifications, etc. You are designing around the device, the platform, the user experience. How can these device features be utilized in our products? How can the mobile device benefit users beyond the screen interface in front of them?

4. Keep scalability in mind

Growing from the previous principle, do remember that a mobile device isn’t just a phone. Scalability across devices, more specifically between a phone and tablet, is a common challenge among designers. When we think of mobile devices, we know there are tablets, phones, phablets (not small enough to be a phone, not big enough to be a tablet). Some of the recurring questions I get asked are: Should there be parity between web and tablet designs? Can we translate the phone patterns to be the same on tablets? How do we design for phablets (not small enough to be a phone, not big enough to be a tablet)? To answer these questions, we researched with users, took an in-depth look at device interfaces and screen sizes, and set some standards. While the phone and tablet share many similarities, users use them very differently.


Mobile interfaces LESS THAN 7 inches width should be treated as a phone. Syntax and layout should be aligned across these devices as much as possible, but we also want to leverage native platform guidelines and capabilities first and foremost.

A fundamental design principle for mobile phones is to include only necessary information. Do not overload the user with more than they need to know or take action on. The phone is a convenient way to consume information on the go. Small business owners use a phone to complete quick actions while they are not in the office, capture data, view content, then perhaps close it out and come back to take a look later.


Mobile interfaces GREATER THAN 7 inches width should be treated as a tablet. Syntax and layout should be aligned across these devices as much as possible, and by no means should they need to align exactly the same as the less than 7-inch interfaces.

Tablet designs should look and feel like desktop web, but they should function like the phone (with tap/swipe/hold gestures, transitions, etc.). Many users view the tablet as a hybrid device. We’ve encountered many small business owners that don’t own a computer, but they own a tablet, and those users treat the tablet as a reliable device they can do work on.

To scale for the future or additional digital interfaces, you should also think about non-mobile touchscreens like TV displays, interactive table displays, automobile displays, laptop displays that you can touch, etc. You want to make sure you can scale for multiple screen sizes, large and small, and not limit yourself to thinking only about the devices your products are being supported by.

Patterns and Guidelines

This list is a small subset of patterns and guidelines that I’ve found designers have been commonly asking around best practices for our mobile products.

Screen Transitions

One of the major aspects that make navigating content on native mobile platforms so delightful is the transitions between screens. Two questions I get asked a lot are: When should a push (screen pushed in leftward from the right) be used? When should a modal (screen pushed upward from the bottom) be used? We’ve established the following best practices:

A push is essentially the fundamental screen transition to view a new screen that is stacked on top of the previous screen. There is typically a Back button so user can view the last viewed screen. For screens that are primarily for viewing, such as transaction detail screens or lists, we use a push.

A modal is typically used when we are requiring the user to select, edit content, or input data. All of our transaction forms use full screen modals as it requires more user thought due to several form fields on one screen. The titles bars for these screens typically have Cancel and Save or Cancel and Done actions. Then, when you tap Save, you get a push screen because you are viewing (not editing) the saved content.

Call to Actions

This section highlights a question I often get: “Should this call to action be a button or a text link?” In both iOS’ and Android’s design guidelines, text as buttons is the norm and recommendation. However, I feel when we use text, especially with a system font against a dark or light background, we lose out on a major opportunity to incorporate brand elements, such as our ecosystem green color or line iconography. So, we’ve deliberately moved away from using text as call to actions, and instead use buttons with high contrast, which also makes it very clear that it is a call to action and not just part of the screen content.

Empty States

Our empty state screens provides a first impression to users who are new to our products. It usually consists of an illustration, a brief description, and a clear call to action. A common and current design trend is the usage of gray text on a light background. If you decide to follow that trend, make sure the text is readable and accessible by analyzing the foreground and background colors to meet the WCAG 2.0 color contrast ratio requirements.


Firstly, yes, it’s spelled caret, not carat or carrot. 🙂 Carets are used to promote discoverability. Historically, we try to use carets for every instance we want to indicate that the user should tap into the row to view more. However, in our forms, we are working toward to moving away from using carets and instead utilize the extra real estate by creating visual cues and conversational content design to indicate tap targets to view more. After some user testing with different design treatments, we’ve found that discoverability isn’t as much of an issue as we thought. Users will naturally tap on rows, whether there’s more information provided to them or not. We only want to use carets when absolutely necessary.

Action Sheets

General rule of thumb for native mobile design: Use action sheets whenever there are multiple actions associated with a single call to action (that is not a system blocker). Apple iOS guidelines calls these action sheets. Google Android calls these bottom sheets. Use action sheets/bottom sheets whenever there are multiple actions associated with a single call to action.

Cards or Tiles

A card (or tile as other teams may call it) is a component acting as a rectangular container for a certain amount of information: visual elements, instructional text, diagrams, and action triggers. There are two types of cards based on appearance and usage: action card and info card.


We use native system dialogs for critical alerts, permissions related alerts, system blocker alerts, etc. The key word is “alert.” Note that for actions that aren’t related to these things, we try to use action sheets.


The general rule for native mobile design is to use system fonts as much as possible. However, we needed to incorporate our brand and voice and tone to create what we call “QuickBooks Ownable Moments.” For large headlines and sub-headlines, we use our brand fonts. For body text, we use system fonts. For fonts within buttons, we use system fonts.


Toggle switches are used to trigger a binary operation (i.e. turning something on and off). It is used often to replace a web checkbox metaphor. We have a lot of checkboxes in our web products so when we design for native mobile, we want to make sure we are only looking to replace binary checkboxes that allows for things like enabling or disabling content, show/hide content or fields, turn on/off tax, track returns for customers, instead of checkboxes used for selecting multiple items.

Again, these are just a few guidelines to get you started or to accelerate your mobile first design process, especially for native mobile. You are the driver and designer with creative license to define the end-to-end user experience for your products and services. Trust your gut, follow your instincts, but always remember to respect the platforms, focus on the customer benefit, think device first, and keep scalability in mind!

Yvonne So is a Principal UX Designer @Intuit currently crafting meaningful experiences for small businesses around the world. With a passion and mission for making technology more inclusive of everyone, she regularly speaks and writes about mobile UX, accessibility, innovation, and empathic design.

Rockland website builder

Next, we can select the type of ad.

We want to make an expandable, so we select Expandable on the left.

Next, we can set again ad’s dimensions.

We are building a 320 by 50that expands to 480 by 250.

So I will make those changes.

We then assign the Rockland creative a name.

I will leave my Save ToLocation as the default, and leave the talk about set to Quick.

Once I’m happy with my settings, I click OK.

Google Web Designer creates the initial pages of the ad for me with the dimensions I defined.


website builder Rockland

The collapsed page already contains a Tap Area event to expand the ad and an expanded pageRockland with a close tap area to collapse back down.

web design requirement

From product design to virtual reality

web design courses

1. Gestures are the new clicks

We forget how hard scrolling webpages used to be. Most users would painstakingly move their mouse to the right edge of the screen, to use something ancient called a ‘scrollbar’:

As a pro, you probably used a mouse wheel, cursor keys, or trackpad, but you were way ahead of most users.

In 2015 it’s far easier to scroll than it is to click. On mobile, you can scroll wildly with your thumb. To click on a precise target is actually more difficult — the complete opposite of what we’re used to on the desktop.

As a result, we should expect more and more websites to be built around scrolling first, and clicking second. And of course, that’s exactly what we’ve seen everywhere:

There’s every reason to expect this trend to continue as mobile takes over more of the market. Modern sites have fewer things to click, and much more scrolling. We’ll see fewer links, more buttons, bigger ‘clickable’ areas, and taller pages that expect to be scrolled.

Websites which spread their articles onto multiple pages will soon learn this lesson. Expect these to turn into longer single pages or even, like TIME magazine, into infinite scrolling pages:

It’s too early to know if the web will expand itself onto devices like watches, but if it ever does, you can bet it’ll be almost entirely driven by gestures.

2. The fold really is dead this time

Now scrolling is so cheap, and devices are so varied in size, ‘the fold’ is finally becoming irrelevant.

Designers are increasingly free to not cram everything at the top of a page. This leads to a design trend popularised by Medium — full-screen image titles, with no content visible until you start scrolling:

With tall, scrolling pages, designers have the chance to do what magazines have taken for granted for years: fill their pages with big beautiful images. In 2015 expect to see more designs that take up much more space — especially vertically — and a lot of larger imagery like this.

3. Users are quicker, websites are simplifying

Today every young adult is an expert web user. And even the amateurs are acting like pros: using multiple tabs, and swiping to go back a page.

The result is that everything is faster. And we’ve all learned to become impatient. If you want to make a mild mannered person explode with annoyance, just make their Internet really slow for a minute.

Now websites are forced not just to become faster (a technical problem), but to become faster to understand. Designs which slow the user down have the same impact on their audience as these websites which don’t load at all.

Simpler designs are easier to scan, which means they’re faster to appreciate. It’s easy to see which of these two designs is newer, and it’s because it’s the one that user’s can enjoy the fastest:

This is the biggest reason for the death of skeuomorphic design: users are more perceptive, less patient, and clutter only slows them down.

Apps put most websites to shame with super-minimal, beautiful interfaces. And they’re doing this because minimal interfaces perform better.

Flat design is just the beginning. The real trend is towards simplicity and immediacy, and we expect that to go further than ever in 2015.

4. The pixel is dead

On a desktop, a pixel was a pixel. You even had an idea of how many pixels made up an average inch: 72 dpi. Nowadays very few people know what a pixel is.

With responsive design, we’ve seen a move towards grids and percentages. But one huge area remains still unchallenged: bitmap images.

Almost all of the web is built with images that have half the resolution of a modern display, and they don’t scale. With Retina displays and modern browsers, the time is right for vector images to become more popular in 2015.

We can see this trend already happening with the font-based icons and Google’s Material design. The website loads faster and scale the icons to any size without losing quality. That makes them ideal for designers and modern web browsers.

The technology exists now, but it will take time for professionals to change their habits to create for higher quality displays. Once the average desktop display becomes Retina-grade (like the new iMac), we expect designers to follow suit.

5. Animation is back

If you want to make a website look dated, cover it with animated “Under Construction” GIFs and Flash animation. But several things are coming together to make animation a rising star in modern web design.

Flat design can end up looking too consistent, boring even. Animation helps a website to stand out and to pack more information into less space.

Mobile apps have redefined what a user expects. Mobile apps use motion to convey meaning, and websites are just starting to do the same.

New technologies like CSS animation make it easy to enhance designs without plugins, speed or compatibility issues. And Web Components (#6, below) will only accelerate this.

GIF animation is back, and surprisingly effective. You’ll notice this article makes extensive use of GIF animation (if it doesn’t, you should view this version), which has never been easier to create or share.

6. Components are the new frameworks

Web technology continues to get more complicated, and less semantic. Designers must embed messy code onto their pages for simple tasks, like including Google Analytics or a Facebook Like button. It would be a lot easier if we could just write something like this instead:

<google-analytics key=”UA-12345–678">

And we can with Web Components, which aren’t quite ready to be used by most designers yet. 2015 is looking like their year.

Google’s Material design is here, and it may just be what gets this movement started. Powered by Polymer, and supported by all modern browsers, it provides the rich animation and interaction components from Android apps, with simple tags like these:

If that takes hold, it wouldn’t be surprising to see more component based frameworks appear in 2015. Perhaps Bootstrap 4.0?

7. Social saturation and the rise of direct email

Social media has been a huge success for consumers, but many content producers aren’t so happy.

The problem is saturation. With billions of posts every day, Facebook learns the posts that users are most likely to enjoy and shows only those. Unfortunately that means over time, what you post is increasingly seen by a smaller percentage of your followers. (A problem you can solve, conveniently, by paying Facebook).

Social isn’t going away, but in 2014 we’ve seen a lot of prominent bloggers like Tim Ferriss move their focus away from social and into good old fashioned email lists. They’ve realised that email has one significant advantage over social: a much higher percentage of people will see what you send them.

I expect this post-social trend to continue into 2015, with the under-appreciated trend of Web Notifications (which work much like notifications in a mobile app).

Bonus non-prediction: CSS shapes

This cool technology won’t get noticed, except by designers. CSS shapes allow you to flow layout into shapes, like circles:

It’s incredibly cool, but until browser support is guaranteed, this is likely to be too risky to put time and effort into it you’d need almost two complete designs, for old and new browsers. And outside of designers, we don’t think many users would notice.

It is really cool though.

What to expect in 2015

In 2014 we saw mobile use overtake desktop, but the general public hasn’t caught up. Most organisations still commission a website to look good on their computer first and work on mobile second.

In 2015 that strategy is likely to look out of touch and unprofessional. As the mobile becomes the main device for browsing the web, “mobile-first” will become less of a buzzword and more of a requirement.

Flat design may be everywhere, but when you look beyond ghost buttons the real trend is that simpler sites are faster at gratifying users.

Simplicity is not just a fashion: it’s the future. Expect it to only continue.

It will become more and more common to embed animation into blog posts, and for motion to signify both premium quality (for those who can afford it) and to support the user experience.

Pixels and the fold will slowly be set aside making more room for scrolling and click-second experiences. Web Components will make it easier to deliver app-like experiences in our websites.

Right now you see the best of mobile app design appearing in web design. With enough time, the difference between an app and a website might almost entirely disappear.

💸 How to budget for your web design project 💸 - Web Design is Broken e05

Interior designers in sri lanka

Your success is our priority. Pixel Advertising Solutions, since the pioneers in advertising encompasses the joy of business heightening its standard day by day whilst presenting the planet with the most innovative and complicated concepts built for the simplest fundamentals.

Our pride as the best advertising agency in Sri Lanka was augmented by having is the only advertising agency to win an International award inside a time period of no less than Half a year since its establishment. Pixel reaches its clientele distributed during the entire global village all the way from Kandy and means that the consumer has what was desired but better yet.

We suggest making Pixel Advertising Solutions your co-partner, because not only we’ve mastered that which you do but additionally because we are the best of what we do. Pixel is popular for excellent documentation for assisting their customers through the initiation in the business, i.e. from making a name until they reach to a supreme level. The mixture of unimaginable innovative concepts along with the updated technology keeps Pixel many years in front of today`s advertising.

Good things about CUSTOMERS
Making money online is vital to us just as much as you should you. Hence we at Pixel bound ourselves to hear your preferences irrespective of the time, place or date!
We make certain you have received the pr�cised service required with a tinge of quality and creativity. It’s our belief that our responsibilities usually do not end hence forth; this is why you can expect an �after sales service�, receive suggestions and feedback with open arms.
The prime end products you feel from Pixel include the final output of true effort in the Pixel team. Pixel team consists of highly qualified, dedicated, free thinking, enthusiastic and even more importantly with persons who’re enthusiastic about their fulfilling tasks. This is why Pixel has succeeded in pushing the boundaries of innovation, producing exclusive products and services, making your dreams possible, and to claim proudly that �NOTHING IS IMPOSSIBLE�.
In a world where, money has set limitations for creativity, Pixel Advertising Solutions offers their excellent products and services for a adjusted price, since in fact the trouble we put into our products and services is priceless�

Branding in sri lanka

web design layout inspiration

Ant (GitHub) is much more than a React UI kit with a minimalist design aesthetic and every component under the sun. It is a rabbit’s hole that leads to a giant maze of interconnected libraries, with a serious ecosystem surrounding it. There’s a custom build tool based on Webpack called ant-tool, several CLI apps, community scaffolds, and a complete framework (dva, which has its own CLI as well). And the UI components are mini-projects in and of themselves — see this repo for information on each component.

Many of these libraries appear to be very polished, including an entire React animation library. And I’d love to learn more about them, but Ant comes with a challenge — the majority of the documentation is in Chinese.

How’s Your Chinese?

Let me preface this by pointing out that the components library and its terrific style guide have been translated into English by generous volunteers, so the UI kit is completely usable. And the translation effort demonstrates the project’s intentions to open up Ant to a wider audience, boding well for companies considering adopting it.

However, there are some language issues that remain. The English is sometimes confusing or obscure. The maintainer of the library has commented here that they welcome PRs for improving the documentation, so that could be a great way to get involved in this amazing project.

Good luck hunting down issues!

Another issue is that issues in Ant.Design are mostly filed and debated on GitHub in Chinese. This could be a deal breaker for enterprise applications, but I’m not sure it should be one for early startups since Ant can be used quite minimally, without making use of smarter features like built-in form validation. Still, if you find an issue or bug with the library, it will be difficult to research previous solutions to your issue, and that’s why I recommend making minimal use of the surrounding ecosystem at this stage.

Battle Tested

Popular UI libraries for React include Material-UI, Semantic-UI, Foundation, and Bootstrap (this and this), and they are all fairly mature. Material-UI should be singled out as it massively eclipses the others in popularity, with over 22k stargazers — and over 600 open issues. But it turns out that Ant.Design is a surprisingly worthy candidate as well. It’s battle tested by some of the most well-trodden sites on the web (Alibaba, Baidu), and it boasts a brilliant style guide, custom tooling, and, of course, a comprehensive catalogue of components. It also has only 85 open issues at the time of writing, which is a good thing considering its popularity.

So let’s take a tour of the library, see what it has to offer, and how to get started using it.

Ant Components

The Ant components list is dizzying. Sure, it contains the basics — modals, forms (inline and vertical), navigation menus, a grid system. But it also contains a ton of extras, such as a @mentioning system, a timeline, badges, a seriously nice table system, and other small fancy features, such as an involved address box (see the Habitual Residence field). Have a look — it has everything that a modern web application should, with a tasteful, minimalist aesthetic.

Design Principles

There’s a nice, concise section in the documentation on the guiding principles of Ant.Design. I found it a great read as it got me thinking a lot about UI/UX considerations, especially the “Provide an Invitation” section, where they discuss different ways of making interactions discoverable by a user. By the way, if anyone can recommend me a good book on UX, I would be grateful.

Grid System

The Ant layout system is comprised of a 24-aliquot (a great new word that I learned from the translated documentation — it means parts of a whole) grid and a separate Layout component than you can choose to use. The grid uses the familiar Row/Col system, but you can also specify a prop called flex which allows you to harness Flexbox properties to define a responsive UI. (See a previous blog post of mine for help grokking the Flex standard.)

Flexbox is now fully supported on just about every browser (with partial support on IE 11 as well as some older mobile browsers), so it should be fine to use. If your customer base is largely Internet Explorer users, which does happen in some industries or countries, you would be wise to abstain from using flex Rows or the Layout component, as Layout is built strictly on Flexbox.

Layout includes components for a Sider, Header, Content, and Footer. Again, these are strictly based on Flexbox, so there’s no choice here — but to be honest I’m not sure what these components give you on top of using the standard Row/Col grid system, aside from a couple extra props you can make use of and possibly some built-in design choices. All in all, it doesn’t seem to me to be hugely useful.

Grid Props

Col elements can be supplied with a span prop to define how many aliquots a column takes up and an offset prop to define an optional offset; Row can take a gutter prop to define space between columns in a row (in pixels, not aliquots).

Here’s a UI example from a side project of mine. It contains one row with two columns:

The code would look something like this:


Ant does not let you down as far as forms are concerned, with options for inline, horizontal, and vertical forms, amazing select boxes, and clear validation messages and icons. In fact, it goes a little overboard here. It allows you to wrap your entire form-rendering component in a higher-order component à la Form.create()(<Component />) to gain access to a built-in validator syntax and custom two-way-binding system (cue audible lip biting). You can then specify standard rules such as ‘required’, or supply custom validator methods. (What are Higher Order Components? Check out this excellent post by James K. Nelson.)

Do you need to use their HOC? Absolutely not, and I’m not sure you should. As I said above, going down that path could expose you to language risk should you encounter bugs and I don’t see why you would want to use a custom two-way binding data system anyway. But you could easily use the HOC and just not use the two-way data binding.

Au Naturel — Plain React Forms

So let’s go over how to use the Ant validation messages without using their higher-order component.

Ant gives us three props that we can supply to each Form.Item component to display validation messages or icons:

  1. validateStatus — This determines the colour & icon scheme of the validation message (see photo above) — valid options are success, warning, error, and validating.
  2. help — The validation message to display.
  3. hasFeedback — This is one of them props that don’t require a value. Just include if you want to display the associated icon, and it defaults to true.
Prettiest validations that I’ve ever seen.

Here’s an example of a simple form element that displays a validation message:

Notice that I used the long-form Form.Item component name. You can make yourself a shortcut for this and any other Ant sub-components as follows:

const FormItem = Form.Item;// .. allows you to use:
<FormItem />

Form Validation using the Ant Higher-Order Component

Now what if we do want to make use of the Ant Form decorator? It’s fairly straightforward to implement. Create your React component class, and then pass it as an argument to Form.create(). The component can then be exported:

class SomeComponent extends React.Component
render() <place_form_here.. />
FancyFormComponent = Form.create()(SomeComponent);export FancyFormComponent as default ; // imported as SomeComponent

Inside your form, decorate your Input fields using the getFieldDecorater method, which exposes a ton of extra props on your component. You can now manipulate form elements directly from the props (eek!).

This example in the documentation gives a thorough demonstration on using the complete higher-order component.

Interactive Components — Message (Alert)

Ant provides a number of other components that give web applications a high degree of interactivity. A great example is alerts — or messages, as they’re called in Ant. Adding an alert is as simple as calling message.success('Great! Item has been saved.') in your component. Message types include success, warning, or error. Just don’t forget to import message (lowercase) from ‘antd’.

Minimalism at its Best

Installing Ant.Design

As I mentioned above, you can either go all-in on the Ant ecosystem (with its custom Webpack adapter), or just opt for the design framework. I went with the latter and I suspect you might too, not the least because using other parts of the ecosystem could require a working knowledge of Chinese. But I’ll cover both options.

Option 1 — Use the CLI

Ant comes with antd-init, a CLI for generating a complete React application with Ant installed. I do not recommend this route for non-Chinese speakers, but if you want to try it, getting started is easy. Just install the CLI using npm, create a new folder, and run antd-init:

npm install antd-init -g; mkdir demo-app; cd $_; antd-init;

You will then be greeted by the following message:

antd-init@2 is only for experience antd. If you want to create projects, it’s better to init with dva-cli. dva is a redux and react based application framework. elm concept, support side effects, hmr, dynamic load and so on.`

It’s a rabbit’s hole. Open your new application and you will see that your familiar webpack.config.js file is no longer familiar — the CLI uses ant-tool, a “Build Tool Based on Webpack” that I mentioned above. The documentation is in Chinese, but it appears to set common defaults for Webpack and then allow you to just supply values that you want to override. Here’s what the config file looks like:

// Learn more on how to config.
// — https://github.com/ant-tool/atool-build#配置扩展module.exports = function(webpackConfig)
libraryName: ‘antd’,
style: ‘css’,
]); return webpackConfig;

The index.js contains a lovely demo page that uses the understated Ant styling.

Option 2 — Use Standard Webpack

This would be my preferred route, but it can be more complicated getting your Webpack settings right at first. The Getting Started page includes some good instructions. First install Ant in your React app:

$ npm install antd --save

Ant recommends using their own babel-plugin-import in your .babelrc:

"presets": [
"plugins": ["transform-decorators-legacy", ..., ["import", [ libraryName: "antd", style: "css" ]]

Make sure your Webpack includes loaders for .js and .css files, and you should be good to go. To use an Ant component, import it in the module file. E.g.

import Row, Col, Icon, Button from 'antd';


There’s no doubt that Ant has a lot to offer as a UI framework, with a formidable catalogue of components and a serious ecosystem around it. It does, however, come with some risk. If you experience an issue with the library, you may be stuck communicating in Chinese. Ultimately I recommend trying it out if you like the minimalist aesthetic, while keeping usage of the peripheral Ant ecosystem to a minimum.