So, really, you’re in the business of designing websites for your clients’ audiences.
But how do you ensure you get it right? You could take what your client tells you at face value, but that’s only going to scrape the surface of who their audience is.
What you need to do is figure out how consumers think and why they respond to websites the way they do. A lot of this is already explained to us by psychology principles.
Once you memorize them, you’ll be able to design user journeys that get visitors to respond exactly as you and your client want them to.
15 Psychology Principles to Use in Web Design
We as humans think certain ways, and your design should cater to those underlying thought processes and natural responses.
Below are 15 psychology principles that’ll help you design better, more intuitive digital experiences for your end-users:
1. Aesthetics-Usability Effect
The Aesthetics-Usability Effect suggests that people equate more attractive interfaces with more usable ones. In other words, a good, modern, responsive design should always be your starting point.
2. Color Psychology
Color psychology tells us about color’s influence over how something is perceived. With color so strongly tied to emotion, you can do a lot to affect how visitors perceive a website and the brand behind it.
3. Psychology of Shapes
Just as a color has the ability to affect someone’s perception of a brand or the content they’re looking at, so too do individual shapes used within an interface. Each shape — circles, squares, triangles, hexagons, and polygons — has a unique psychological association.
4. Gestalt Principles
Gestalt Principles are a way for humans to make sense of chaotic data presented to them. So, rather than see a bunch of text, images, and space, the human brain recognizes patterns to simplify complexity.
About half a dozen principles are associated with this theory, and they’re related to factors like symmetry, similarity, and proximity.
5. Mere-Exposure Effect / Jakob’s Law
The Mere-Exposure Effect, or Familiarity Principle, suggests that people are more likely to prefer things that seem familiar.
Jakob’s Law applies this psychology specifically to the internet user experience. It suggests that users expect your website to work the same way as the other sites they spend their time on.
6. Von Restorff Effect
The Von Restorff Effect, or Isolation Effect, describes what happens when someone is exposed to identical stimuli, and then a unique element is introduced to the fold. It’s the outlier that will most effectively grab their attention.
7. Selective Disregard
Selective disregard is a type of “blindness” users develop to anything seemingly irrelevant to their main goal. This often occurs when a design or marketing trend grows stale — like websites that use the exact same cookie consent banner.
8. Hick’s Law
Hick’s Law states that the number of choices a person has to make will increase the amount of time it takes to make a decision.
This is a fundamental principle to pay attention to on ecommerce sites as you want to speed up the decision-making process, not slow it down.
9. Loss Aversion
Loss Aversion states that decision-making is more commonly driven by avoiding losses than acquiring gains.
If your website or the content within it gives visitors any reason not to trust it or feel confident in taking action, you’re more likely to see high abandonment rates than conversions.
10. Paradox of Choice
The Paradox of Choice is a response to the problem posited by Hick’s Law. It suggests that the reduction of choices makes consumers feel less anxious, which, in turn, increases confidence and satisfaction with purchases.
If your site suffers from high cart abandonment or product returns, the paradox of choice would be a useful principle to leverage.
11. Miller’s Law
Miller’s Law, also referred to as Cognitive Load Theory, has to do with memory capacity. On average, people can only have about seven items stored in their working memory at any given time.
This psychology principle encourages the reduction of options and the general reduction of content to improve focus and decision-making capabilities.
12. Feedback
Feedback is one of the principles of learning and plays a big part in interaction design.
Feedback is what designers use to tell people when they’ve made progress towards a goal or achieved it. You can also use it to teach visitors how a website will respond to their actions, which encourages faster and more confident engagements with your website.
13. Extrinsic Motivation
There are two types of motivation. Intrinsic motivation is an internal one, whereas extrinsic is external.
It’s Extrinsic Motivation that plays a role in getting users to complete more tasks online. As a designer, you have to make sure these kinds of “rewards” are obvious.
14. Social Proof
Not so much a psychological principle as it is a psychological phenomenon, Social Proof or Influence, suggests that people will copy the actions of the masses. It also refers to the assumption that the truth lies with the majority.
This is why customer reviews, client testimonials, and user-generated content have become so useful on websites.
15. Peak-End Rule
The Peak-End Rule states that people will judge an experience based on their very first and last impressions of it. This is somewhat related to the Serial Position Effect, whereby people will remember the first and last items in a group.
So, this is something to remember when you build out the top and bottom of each page as well as the start and expected end to the user journey.
Wrap-Up
Want to build better websites? Then, you need to design from the end users’ perspective.
The best place to start is with psychology principles, as they’ll tell you how most consumers think and what motivates them to respond. If you understand this inherent cause-and-effect relationship, you can design websites that elicit the right kind of response from your visitors.
I had a very embarrassing CSS moment the other day.
I was working on the front-end code of a design that had a narrow sidebar of icons. There isn’t enough room there to show text of what the icons are, so the idea is that we’ll use accessible (but visually hidden, by default) text that is in there already as a tooltip on a “long hover.” That is, a device with a cursor, and the cursor hovering over the element for a while, like three seconds.
So, my mind went like this…
I can use state: the tooltip is either visible or not visible. I’ll manage the state, which will manifest in the DOM as a class name on an HTML element.
Then I’ll deal with the logic for changing that state.
The default state will be not visible, but if the mouse is inside the element for over three seconds, I’ll switch the state to visible.
If the mouse ever leaves the element, the state will remain (or become) not visible.
This was a React project, so state was just on the mind. That ended up like this:
CodePen Embed Fallback
Not that bad, right? Eh. Having state managed in JavaScript does potentially open some doors, but in this case, it was total overkill. Aside from the fact that I find mouseenter and mouseleave a little finicky, CSS could have done the entire thing, and with less code.
That’s the embarrassing part… why would I reach up the chain to a JavaScript library to do this when the CSS that I’m already writing can handle it?
I’ll leave the UI in React, but rip out all the state management stuff. All I’ll do is add a transition-delay: 3s when the .icon is :hover so that it’s zero seconds when not hovered, then goes away immediately when the mouse cursor leaves).
CodePen Embed Fallback
A long hover is basically a one-liner in CSS:
.thing {
transition: 0.2s;
}
.thing:hover {
transision-delay: 3s; /* delay hover animation only ON, not OFF */
}
Works great.
One problem that isn’t addressed here is the touch screen problem. You could argue screen readers are OK with the accessible text and desktop browsers are OK because of the custom tooltips, but users with touch-only screens might be unable to discover the icon labels. In my case, I was building for a large screen scenario that assumes cursors, but I don’t think all-is-lost for touch screens. If the element is a link, the :hover might fire on first-tap anyway. If the link takes you somewhere with a clear title, that might be enough context. And you can always go back to more JavaScript and handle touch events.
It could be a task as easy as pie or difficult as breaking a mountain, depending on how you implement the tips for creating effective business flyers.
We’re bringing some easy-to-digest tips for EFFECTIVE flyer design that sums-up our experience with successful & failing flyers. Big shots may have costly flyer maker at their disposal; small businesses are often vulnerable in this case. No matter if it is your first ever experience designing a flyer or you’ve been doing it a dozen times, you need this shot of motivation for a polished flyer design.
You’ll love to explore our good flyers tip handpicked by our experts just for you.
15 Foolproof Business Flyer Tips for the Win
1. Go For a Catchy Headline
The headline is the heart & soul of your flyer design. The more impactful it is, the more you’ve got chances to be successful for the marketing strategy. Your title should be extremely eye-catchy, provocative, memorable & inspiring.
In short, you win or lose at the title of your flyer. So, make sure this tip for an effective flyer is implemented for pin-point & outstanding design.
2. Don’t Forget to Include a Call-To-Action
What do you want your target audience to do after reading your flyer? This defines your intent for the flyer design. You may want them to:
Walk-in at your restaurant to avail of the offer
Call you for bookings
Reach out to you for a free consultation, and so on.
Make sure your flyer has a CTA to make this flyer marketing campaign successful.
3. Never Settle for Anything Less Than TRENDING
Be very careful with the kind of design you choose for your flyer. The template is expected to be contemporary & unique to make a great 1st impression among the target audience. Always opt for a futuristic flyer design that fits your promotion theme & is the best-in-class according to your niche. If your flyer is old-fashioned or outdated, your business is likely to be assumed similar. You better be picky in this case because the creative ways to make flyer is endless!
4. Keep It Simple & Understandable
Your inner self may want to pour so much for the occasion, but you should limit yourself to be less fancy. Keep your target audience in mind & think about their understanding capabilities. Use simple words in a creative fashion instead of using overwhelming language that’s hard to digest. The simpler your flyer is, the more it will be uncomplicated.
5. Make Your Intents Clear
What if you receive a flyer that displays a nice furniture collection, but the store owner forgot to add a CTA? You’ll be puzzled as to what you should conclude after all these efforts, right?
The most important thing to keep at the core of a flyer design is to clear your intentions first. Promotional content is mainly intended to drive leads & increase customer flow. But, this should be clearly visible with the flyer itself. The key to a successful flyer design is to personalize it with a goal & stick to it throughout the flyer.
6. Be Specific With the Colors
Every color has a meaning. Depending on the colors you choose for your flyer, they’ll carry meaning among the readers. For instance, red symbolizes the brand’s revolution, strength, and passion. Similarly, orange is perceived as a color of friendliness, courage, and confidence.
White represents freshness, purity, faith, safety, etc. Thus, define your color palette in such a way that it blends with your purpose & brand colors, of course.
This creative flyer tip should always be in your back pocket.
7. Don’t Make Overwhelming Use of Fonts
It’s great if you have a sound knowledge of font-pairing. You can utilize it to smartly combine more than three fonts for an extravagant appeal. If this isn’t your cup-of-tea, you better go with the standard font combinations. Don’t experiment with more than three fonts for a feel-good appeal. This is one of the most considerable flyer design tips that make or break the look.
8. Say NO to Anything that isn’t High Resolution
Whether it is about stock images or the pictures you upload make sure it is HD only. Taking care of this will help you ensure that the hard-copy prints aren’t blurry or low-quality. Also, if you share your flyers via Emails or share them on social media, they won’t distort upon zoom-in. This is what makes it look professional after all!
9. Know & Include Your Essentials
It’s you who knows the basic details that must be present on your flyer design. Usually, companies include contact details (address, phone no., Email, etc.) & company logo as the default information. The main intention to add these details is to let your target audience know where they should reach out to you.
10. Set Your Flyer Tone “Engaging”
Like every pebble makes the shore, you should use each flyer element wisely as it defines the overall tone of your flyer design. Mostly, promotional flyers are shout-outs for products or services & it should be a positive tone to make your target audience want to try them at least once.
Above all, the baseline theme should be highly engaging & utterly impressive so that people want to check out every bit of your flyer design.
11. Proofreading is MUST
“Not proofreading your content means leaving loopholes in your design.” – This should never ever happen to your flyer. Check & double-check each piece of content on your flyer, including the name mentioned in the contact information, Email, etc. It may take a few extra minutes, but it is better than making a false & unprofessional impression after thousands of your flyers are printed.
12. Opt For Free Flyer Designing Resources, Whenever Possible
Who says you have to spend lavishly or hire a graphic designer compulsorily if you want a dashing & professional-looking flyer? You’ve got so many options online.
Hey! Have you tried PhotoADKing? We’ve got incredible flyer templates & endless choices for graphics, illustrations, and stock images to grace your flyer designs. Feel free to explore our collection hereby! So, when you know a free resource, be keen enough to discover something new & do the needful to your brand promotions.
13. Add Attractive Discounts/Limited-Time Deals For Faster Conversions
Take this as your call to inspire your target audience to reach you as soon as possible. Your flyer design must have at least one sticker or illustration where you highlight your offer.
It could be something like “Hurry…Limited Time Offer,” “1st 100 Customers get Surprise Gifts,” “Flat 10% OFF on your 1st Order,” etc.
14. Prefer Graphics Over Words
Why use text when you can use icons? Similarly, you may have a number of instances to make your flyer interesting with the least use of words. Though it is essential to add text wherever necessary, it’s good if you make the overall look clutter-free by replacing graphics with words wherever possible.
15. Focus more on the Benefits of your Products/Services
Your brand name & other flyer elements are important. But, your focus should be on explaining the benefits of your products or services to your target audience. Tell them how your product/service will solve their problem instead of saying “Our product is good at this or that.”
The Takeaway
Now you have the secret recipe for making your flyer design successful. Use This all flyer makertips while creating flyers for your business. We hope you’ll design better flyer templates from now onwards. Also, you should have a look at PhotoADKing’s free flyer designs that are premade by professional designers & available for all niches. You’ll surely find one to edit in minutes & save your time & efforts.
Chris’s tried-and-true technique works well when you want to leverage automated word breaks and hyphenation rules that are baked into the browser:
.dont-break-out {
/* These are technically the same, but use both */
overflow-wrap: break-word;
word-wrap: break-word;
word-break: break-word;
/* Adds a hyphen where the word breaks, if supported (No Blink) */
hyphens: auto;
}
But what if you can’t? What if your style guide requires you to break URLs in certain places? These classic sledgehammers are too imprecise for that level of control. We need a different way to either tell the browser exactly where to make a break.
Why we need to care about line breaks in URLs
One reason is design. A URL that overflows its container is just plain gross to look at.
Then there’s copywriting standards. The Chicago Manual of Style, for example, specifies when to break URLs in print. Then again, Chicago gives us a pass for electronic documents… sorta:
It is generally unnecessary to specify breaks for URLs in electronic publications formats with reflowable text, and authors should avoid forcing them to break in their manuscripts.
But what if, like Rachel Andrew (2015) encourages us, you’re designing for print, not just screens? Suddenly, “generally unnecessary” becomes “absolutely imperative.” Whether you’re publishing a book, or you want to create a PDF version of a research paper you wrote in HTML, or you’re designing an online CV, or you have a reference list at the end of your blog post, or you simply care how URLs look in your project—you’d want a way to manage line breaks with a greater degree of control.
OK, so we’ve established why considering line breaks in URLs is a thing, and that there are use cases where they’re actually super important. But that leads us to another key question…
Where are line breaks supposed to go, then?
We want URLs to be readable. We also don’t want them to be ugly, at least no uglier than necessary. Continuing with Chicago’s advice, we should break long URLs based on punctuation, to help signal to the reader that the URL continues on the next line. That would include any of the following places:
After a colon or a double slash (//)
Before a single slash (/), a tilde (~), a period, a comma, a hyphen, an underline (aka an underscore, _), a question mark, a number sign, or a percent symbol
Before or after an equals sign or an ampersand (&)
At the same time, we don’t want to inject new punctuation, like when we might reach for hyphens: auto; rules in CSS to break up long words. Soft or “shy” hyphens are great for breaking words, but bad news for URLs. It’s not as big a deal on screens, since soft hyphens don’t interfere with copy-and-paste, for example. But a user could still mistake a soft hyphen as part of the URL—hyphens are often in URLs, after all. So we definitely don’t want hyphens in print that aren’t actually part of the URL. Reading long URLs is already hard enough without breaking words inside them.
We still can break particularly long words and strings within URLs. Just not with hyphens. For the most part, Chicago leaves word breaks inside URLs to discretion. Our primary goal is to break URLs before and after the appropriate punctuation marks.
How do you control line breaks?
Fortunately, there’s an (under-appreciated) HTML element for this express purpose: the element, which represents a line break opportunity. It’s a way to tell the browser, Please break the line here if you need to, not just any-old place.
We can take a gnarly URL, like the one Chris first shared in his 2012 post:
Even if you’re the most masochistic typesetter ever born, you’d probably mark up a URL like that exactly zero times before you’d start wondering if there’s a way to automate those line break opportunities.
Yes, yes there is. Cue JavaScript and some aptly placed regular expressions:
/**
* Insert line break opportunities into a URL
*/
function formatUrl(url) {
// Split the URL into an array to distinguish double slashes from single slashes
var doubleSlash = url.split('//')
// Format the strings on either side of double slashes separately
var formatted = doubleSlash.map(str =>
// Insert a word break opportunity after a colon
str.replace(/(?<after>:)/giu, '$1<wbr>')
// Before a single slash, tilde, period, comma, hyphen, underline, question mark, number sign, or percent symbol
.replace(/(?<before>[/~.,-_?#%])/giu, '<wbr>$1')
// Before and after an equals sign or ampersand
.replace(/(?<beforeAndAfter>[=&])/giu, '<wbr>$1<wbr>')
// Reconnect the strings with word break opportunities after double slashes
).join('//<wbr>')
return formatted
}
Try it out
Go ahead and open the following demo in a new window, then try resizing the browser to see how the long URLs break.
CodePen Embed Fallback
This does exactly what we want:
The URLs break at appropriate spots.
There is no additional punctuation that could be confused as part of the URL.
The tags are auto-generated to relieve us from inserting them manually in the markup.
This JavaScript solution works even better if you’re leveraging a static site generator. That way, you don’t have to run a script on the client just to format URLs. I’ve got a working example on my personal site built with Eleventy.
If you really want to break long words inside URLs too, then I’d recommend inserting those few tags by hand. The Chicago Manual of Style has a whole section on word division (7.36–47, login required).
Browser support
The element has been seen in the wild since 2001. It was finally standardized with HTML5, so it works in nearly every browser at this point. Strangely enough, worked in Internet Explorer (IE) 6 and 7, but was dropped in IE 8, onward. Support has always existed in Edget, so it’s just a matter of dealing with IE or other legacy browsers. Some popular HTML-to-PDF programs, like Prince, also need a boost to handle .
One more possible solution
There’s one more trick to optimize line break opportunities. We can use a pseudo-element to insert a zero width space, which is how the element is meant to behave in UTF-8 encoded pages anyhow. That’ll at least push support back to IE 9, and perhaps more importantly, work with Prince.
/**
* IE 8–11 and Prince don’t recognize the `wbr` element,
* but a pseudo-element can achieve the same effect with IE 9+ and Prince.
*/
wbr:before {
/* Unicode zero width space */
content: "200B";
white-space: normal;
}
Striving for print-quality HTML, CSS, and JavaScript is hardly new, but it is undergoing a bit of a renaissance. Even if you don’t design for print or follow Chicago style, it’s still a worthwhile goal to write your HTML and CSS with URLs and line breaks in mind.
———. 2018. “Where Lines Break is Complicated. Here’s all the Related CSS and HTML.” CSS-Tricks, May 9, 2018. Last modified April 24, 2020. https://css-tricks.com/where-lines-break-is-complicated-heres-all-the-related-css-and-html/.
We’ve been big fans of Ghost since it first launched via a Kickstarter campaign way back in 2013. Ghost 4.0 has just been released, and the host of new features is another giant leap forward for the popular blogging platform.
The content management space is one of the most crowded for startups; there are traditional CMS, headless CMS, site builders, and the omnipresent WordPress, which, if current trends persist, will power 729% of the web by next Thursday.
Ghost is a blog-focused CMS, as WordPress is. Unlike WordPress, it’s minimal, fast, and a pleasure to use.
To survive in the competitive space, Ghost has niched-down to specializing in monetized content — charging membership for sites to bring in revenue for the site owner (Ghost doesn’t charge any commission on this income). As part of that effort, Ghost 4.0’s new engagement-centered dashboard is designed to help you fine-tune your content for profitability.
For any release right now, a dark mode is almost mandatory, and Ghost 4.0 includes it. It may sound like a vanity feature, but once you find yourself working late writing and editing content, your battery and your eyes will thank you for it.
Other notable features include a brand new theme store with professional templates that install with a single click and built-in email newsletters to help foster a sense of site-loyalty among your fanbase.
Ghost is one of the best writing experiences in its class and one of the best publishing experiences for individual creators. If you like publishing on Medium, but wish you had more ownership of your content, then you should give Ghost a try.
There wasn’t/isn’t/and never will be a time when customers don’t have to repair their electronic devices.
From washing machines and refrigerators to smartphones and laptops, all of us have hit our heads while trying to fix them by ourselves. So customers need technicians who can mend devices and bring them back to working condition. But unfortunately, the world is going through challenging times. The coronavirus pandemic has called for numerous lockdowns across the globe. People aren’t able to travel to their destinations freely as the governments have imposed several restrictions. It has resulted in severe implications across industries as employees, especially on-site technicians, have lost their jobs. Virtual remote assistance has become a boon for such people as it helps them come back to jobs and provide service to customers.
What is virtual remote assistance?
Since on-site technicians cannot travel to the customer’s place, there is a need to provide service remotely. It’s known as virtual remote assistance and the following are the ways that it can be provided.
Through call
Through live chat sessions
Through emails
Through visual remote assistance
Companies have been using the first three ways for many decades. But the fourth one, visual remote assistance, is new.
What are visual remote assistance and its applications?
When a technician provides help through visual means, it is called visual remote assistance. For example, a technician provides instructions through a graphical screen installed on the equipment that requires repair.
The following are the instances where visual remote assistance can be used:
1. Technicians provide solutions remotely
Consider the case where the customer’s washing machine breaks down and the on-site technician cannot reach the customer’s place. In that case, the technician can provide remote assistance in two ways.
a. The customer can install an application on their smartphone. The smartphone camera will allow the technician to observe the problem and provide a relevant solution.
b. The customer doesn’t need to install any web application. They can click on a link in the chatbox, which will start a video-conference through which the technician can observe the problem remotely.
2. Expert helps the on-site technician
Consider the case where the customer’s laptop isn’t functioning. They place a request on the company’s website, and the technician goes to the customer’s place the next day. Unfortunately, the technician is unable to understand/solve the problem. He calls the expert in the company headquarters and asks for guidance. The expert provides the relevant details, and the technician repairs the laptop successfully.
3. The customer receives a combination of visual remote assistance and in-person support.
Consider the case where the customer’s music system isn’t working correctly and requires a new disk player. If the on-site technician is unavailable, the company can ask a local vendor to deliver a brand-new disk player to the customer’s home. After that, the technician can remotely assist the customer by providing a step by step description of installing the disk player.
Benefits of visual remote assistance
Technicians are required in all industries, but apart from the ongoing coronavirus pandemic, numerous factors deter technicians from continuing their services. Some of them are mentioned below:
Technicians have to travel extensively, which makes them prone to extreme climatic conditions. Studies show that harmful substances or environments cause 10% of workplace deaths.
Technicians usually work in an environment that is full of heavy machinery. According to statistics, 14% of workplace deaths occur due to contact with objects and equipment.
Many excellent technicians leave their job due to degrading health concerns and travel requirements.
Visual remote assistance provides a convenient solution to all these problems by allowing technicians to provide service remotely. It also reduces company costs as they no longer need to buy expensive transport tickets. Moreover, the lesser vehicles travel on the road, the lesser the emissions and the roads’ wear and tear.
Visual remote assistance will help companies attract and retain top-notch talent.
The pandemic has revealed the significance of remote work because the first ones to lose their jobs were the people who couldn’t work remotely. Companies can attract and retain top-notch talent if they implement technologies that help technicians deliver service anytime and anywhere without the need to do on-site work themselves.
Customer Relationship Management (CRM) software is the best tool to start with if you are serious about implementing visual remote assistance. It has a vast repository where customers can find solutions to their problems instantly. They can also post queries and connect with technicians to get help in real-time. CRM software also has a chatbot feature that gathers critical information about the customer and separates them into different categories.
Conclusion
Visual remote assistance is fast becoming the norm in the service delivery industry, as explained in the aforementioned points. Companies can also ensure the safety of their employees and customers and minimize their expenses.
The JS Party podcast sometimes hosts game shows. One of them is Jeopardy-esque, called JS Danger, and some of us here from CSS-Tricks got to be the guests this past week! The YouTube video of it kicks off at about 5:56.
While I’m at it…
Here’s some more videos I’ve enjoyed recently.
Past episodes of JS Danger are of course just as fun to watch!
Kevin Powell takes on a classic CSS confusion… what’s the difference between width: auto; and width: 100%;?
More like automatically distribute the space amiright?
Jeremy Keith on Design Principles For The Web:
John Allsopp with A History of the Web in 100 Pages. The intro video is three pages, and not embeddable presumably because the context of the blog post is important… this is just a prototype to hopefully complete the whole project!
And then recently while listening to A History of the World in 100 objects, it occurred to me that that model might well work for telling the story of the Web–A History of the Web told through 100 Pages. By telling the story of 100 influential pages in the Web’s history (out of the now half a trillion pages archived by the wayback machine), might we tell a meaningful history of the Web?
Low poly has been a hot topic on and off in the last couple of years. Even if you haven’t heard the term before you probably have seen it at least a dozen times.
The term low poly is the shortened version of “low polygon” which mainly consists of simple 2d shapes coming together to form a pattern/shape. Low poly art is made of numerous low polygon shapes put together to create images, games, etc.
Even though low poly imagery was used due to the limited technical capacity in rendering images it has also piqued the interest of digital artists and continues to be quite popular.
Low poly assets were mainly used in old video games as the consoles and computers didn’t have the processing power for higher resolution graphics. However, as low poly has regained its popularity, it has also re-emerged in, especially, indie games.
There’s just something about low poly art that catches the attention of people and that’s probably the main reason why it’s still popular despite the fact that the cheapest smartphones being miles ahead of the strongest computer back in the day.
So without further ado, let’s have a look at some of our favorite low poly art examples.
All in all, low poly art was created out of necessities but as we’ve seen time and time again, sometimes there’s beauty in simple things. Low poly art is a testament to that. We really love the simplicity that low poly art brings with it and plan to update this article as we come across new artists and their artwork. If you have any good examples that we might have missed, leave us a comment with your suggestions.
For years, my pain has been not being able to create a somewhat natural-looking pattern in CSS. I mean, sometimes all I need is a wood texture. The only production-friendly solution I knew of was to use an external image, but external images are an additional dependency and they introduce a new complexity.
I know now that a good portion of these problems could be solved with a few lines of SVG.
There is a Filter Primitive in SVG called . It’s special in the sense that it doesn’t need any input image — the filter primitive itself generates an image. It produces so-called Perlin noise which is a type of noise gradient. Perlin noise is heavily used in computer generated graphics for creating all sorts of textures. comes with options to create multiple types of noise textures and millions of variations per type.
All of these are generated with .
“So what?” you might ask. These textures are certainly noisy, but they also contain hidden patterns which we can uncover by pairing them with other filters! That’s what we’re about to jump into.
Creating SVG filters
A custom filter typically consists of multiple filter primitives chained together to achieve a desired outcome. In SVG, we can describe these in a declarative way with the element and a number of elements. A declared filter can then be applied on a renderable element — like , , , , etc. — by referencing the filter’s id. The following snippet shows an empty filter identified as coolEffect, and applied on a full width and height .
<svg xmlns="http://www.w3.org/2000/svg">
<filter id="coolEffect">
<!-- Filter primitives will be written here -->
</filter>
<rect width="100%" height="100%" filter="url(#coolEffect)"/>
</svg>
SVG offers more than a dozen different filter primitives but let’s start with a relatively easy one, . It does exactly what it says: it floods a target area. (This also doesn’t need an input image.) The target area is technically the filter primitive’s sub-region within the region.
Both the filter region and the filter primitive’s sub-region can be customized. However, we will use the defaults throughout this article, which is practically the full area of our rectangle. The following snippet makes our rectangle red and semi-transparent by setting the flood-color (red) and flood-opacity (0.5) attributes.
A semi-transparent red rectangle looks light red on a white background and dark red on a black background because the opacity is set to 0.5.
Now let’s look at the primitive. It’s used for blending multiple inputs. One of our inputs can be SourceGraphic, a keyword that represents the original graphic on which the filter is applied.
Our original graphic is a black rectangle — that’s because we haven’t specified the fill on the and the default fill color is black. Our other input is the result of the primitive. As you can see below we’ve added the result attribute to to name its output. We are referencing this output in with the in attribute, and the SourceGraphic with the in2 attribute.
The default blend mode is normal and the input order matters. I would describe our blending operation as putting the semi-transparent red rectangle on top of the black rectangle.
Now, our rectangle is dark red, no matter what color the background is behind it. That’s because we stacked our semi-transparent red on top of the black and blended the two together with , we chained the result of to .
Chaining filter primitives is a pretty frequent operation and, luckily, it has useful defaults that have been standardized. In our example above, we could have omitted the result attribute in as well as the in attribute in , because any subsequent filter will use the result of the previous filter as its input. We will use this shortcut quite often throughout this article.
Generating random patterns with feTurbulence
has a few attributes that determine the noise pattern it produces. Let’s walk through these, one by one.
baseFrequency
This is the most important attribute because it is required in order to create a pattern. It accepts one or two numeric values. Specifying two numbers defines the frequency along the x- and y-axis, respectively. If only one number is provided, then it defines the frequency along both axes. A reasonable interval for the values is between 0.001 and 1, where a low value results in large “features” and a high value results in smaller “features.” The greater the difference between the x and y frequencies, the more “stretched” the pattern becomes.
The baseFrequency values in the top row, from left to right: 0.01, 0.1, 1. Bottom row: 0.01 0.1, 0.1 0.01, 0.001 1.
type
The type attribute takes one of two values: turbulence (the default) or fractalNoise, which is what I typically use. fractalNoise produces the same kind of pattern across the red, green, blue and alpha (RGBA) channels, whereas turbulence in the alpha channel is different from those in RGB. I find it tough to describe the difference, but it’s much easier to see when comparing the visual results.
The turbulence type (left) compared to the fractalNoise type (right)
numOctaves
The concept of octaves might be familiar to you from music or physics. A high octave doubles the frequency. And, for in SVG, the numOctaves attribute defines the number of octaves to render over the baseFrequency.
The default numOctaves value is 1, which means it renders noise at the base frequency. Any additional octave doubles the frequency and halves the amplitude. The higher this number goes, the less visible its effect will be. Also, more octaves mean more calculation, possibly hurting performance. I typically use values between 1-5 and only use it to refine a pattern.
numOctaves values compared: 1 (left), 2 (center), and 5 (right)
seed
The seed attribute creates different instances of noise, and serves as the the starting number for the noise generator, which produces pseudo-random numbers under the hood. If the seed value is defined, a different instance of noise will appear, but with the same qualities. Its default value is 0 and positive integers are interpreted (although 0 and 1 are considered to be the same seed). Floats are truncated.
This attribute is best for adding a unique touch to a pattern. For example, a random seed can be generated on a visit to a page so that every visitor will get a slightly different pattern. A practical interval for generating random seeds is from 0 to 9999999 due to some technical details and single precision floats. But still, that’s 10 million different instances, which hopefully covers most cases.
seed values compared: 1 (left), 2 (center), and 7329663 (right)
stitchTiles
We can tile a pattern the same sort of way we can use background-repeat: repeat in CSS! All we need is the stitchTiles attribute, which accepts one of two keyword values: noStitch and stitch, where noStitch is the default value. stitch repeats the pattern seamlessly along both axes.
Comparing noStitch (top) to stitch (bottom)
Note that also produces noise in the Alpha channel, meaning the images are semi-transparent, rather than fully opaque.
Patterns Gallery
Let’s look at a bunch of awesome patterns made with SVG filters and figure out how they work!
Starry Sky
CodePen Embed Fallback
This pattern consists of two chained filter effects on a full width and height rectangle. is the first filter, responsible for generating noise. is the second filter effect, and it alters the input image, pixel by pixel. We can tell specifically what each output channel value should be based on a constant and all the input channel values within a pixel. The formula per channel looks like this:
is the output channel value
are the input channel values
are the weights
So, for example, we can write a formula for the Red channel that only considers the Green channel by setting to 1, and setting the other weights to 0. We can write similar formulas for the Green and Blue channels that only consider the Blue and Red channels, respectively. For the Alpha channel, we can set (the constant) to 1 and the other weights to 0 to create a fully opaque image. These four formulas perform a hue rotation.
The formulas can also be written as matrix multiplication, which is the origin of the name . Though can be used without understanding matrix operations, we need to keep in mind that our 4×5 matrix are the 4×5 weights of the four formulas.
is the weight of Red channel’s contribution to the Red channel.
is the weight of Red channel’s contribution to the Green channel.
is the weight of Green channel’s contribution to the Red channel.
is the weight of Green channel’s contribution to the Green channel.
The description of the remaining 16 weights are omitted for the sake ofbrevity
The hue rotation mentioned above is written like this:
It’s important to note that the RGBA values are floats ranging from 0 to 1, inclusive (rather than integers ranging from 0 to 255 as you might expect). The weights can be any float, although at the end of the calculations any result below 0 is clamped to 0, and anything above 1 is clamped to 1. The starry sky pattern relies on this clamping, since it’s matrix is this:
The transfer function described by for the R, G, and B channels. The input is always Alpha.
We are using the same formula for the RGB channels which means we are producing a grayscale image. The formula is multiplying the value from the Alpha channel by nine, then removing four from it. Remember, even Alpha values vary in the output of . Most resulting values will not be within the 0 to 1 range; thus they will be clamped. So, our image is mostly either black or white — black being the sky, and white being the brightest stars; the remaining few in-between values are dim stars. We are setting the Alpha channel to a constant of 1 in the fourth row, meaning the image is fully opaque.
Pine Wood
CodePen Embed Fallback
This code is not much different from what we just saw in Starry Sky. It’s really just some noise generation and color matrix transformation. A typical wooden pattern has features that are longer in one dimension than the other. To mimic this effect, we are creating “stretched” noise with by setting baseFrequency="0.1 0.01". Furthermore, we are setting type="fractalNoise".
With , we are simply recoloring our longer pattern. And, once again, the Alpha channel is used as an input for variance. This time, however, we are offsetting the RGB channels by constant weights that are greater than the weights applied on the Alpha input. This ensures that all the pixels of the image remain within a certain color range. Finding the best color range requires a little bit of playing around with the values.
Mapping Alpha values to colors with While it’s extremely subtle, the second bar is a gradient.
It’s essential to understand that the matrix operates in the linearized RGB color space by default. The color purple (#800080), for example, is represented by values , , and . It might look odd at first, but there’s a good reason for using linearized RGB for some transformations. This article provides a good answer for the why, and this article is great for diving into the how.
At the end of the day, all it means is that we need to convert our usual #RRGGBB values to the linearized RGB space. I used this color space tool to do that. Input the RGB values in the first line then use the values from the third line. In the case of our purple example, we would input , , in the first line and hit the sRGB8 button to get the linearized values in the third line.
If we pick our values right and perform the conversions correctly, we end up with something that resembles the colors of pine wood.
Dalmatian Spots
CodePen Embed Fallback
This example spices things up a bit by introducing filter. This effect allows us to define custom transfer functions per color channel (also known as color component). We’re only defining one custom transfer function in this demo for the Alpha channel and leave the other channels undefined (which means identity function will be applied). We use the discrete type to set a step function. The steps are described by space-separated numeric values in the tableValues attribute. tableValues control the number of steps and the height of each step.
Let’s consider examples where we play around with the tableValues value. Our goal is to create a “spotty” pattern out of the noise. Here’s what we know:
tableValues="1" transfers each value to 1.
tableValues="0" transfers each value to 0.
tableValues="0 1" transfers values below 0.5 to 0 and values from 0.5 to 1.
tableValues="1 0" transfers values below 0.5 to 1 and values from 0.5 to 0.
Three simple step functions. The third (right) shows what is used in Dalmatian Spots.
It’s worth playing around with this attribute to better understand its capabilities and the quality of our noise. After some experimenting we arrive at tableValues="0 1 0" which translates mid-range values to 1 and others to 0.
The last filter effect in this example is which is used to recolor the pattern. Specifically, it makes the transparent parts (Alpha = 0) black and the opaque parts (Alpha = 1) white.
Finally, we fine-tune the pattern with . Setting numOctaves="2" helps make the spots a little more “jagged” and reduces elongated spots. The baseFrequency="0.06" basically sets a zoom level which I think is best for this pattern.
ERDL Camouflage
CodePen Embed Fallback
The ERDL pattern was developed for disguising of military personnel, equipment, and installation. In recent decades, it found its way into clothing. The pattern consists of four colors: a darker green for the backdrop, brown for the shapes shapes, a yellowish-green for patches, and black sprinkled in as little blobs.
Similarly to the Dalmatian Spots example we looked at, we are chaining to the noise — although this time the discrete functions are defined for the RGB channels.
Imagine that the RGBA channels are four layers of the image. We create blobs in three layers by defining single-step functions. The step starts at different positions for each function, producing a different number of blobs on each layer. The cuts for Red, Green and Blue are 66.67%, 60% and 50%, respectively..
At this point, the blobs on each layers overlap in some places, resulting colors we don’t want. These other colors make it more difficult to transform our pattern into an ERDL camouflage, so let’s eliminate them:
For Red, we define the identity function.
For Green, our starting point is the identity function but we subtract the Red from it.
For Blue, our starting point is the identity function as well, but we subtract the Red and Green from it.
These rules mean Red remains where Red and Green and/or Blue once overlapped; Green remains where Green and Blue overlapped. The resulting image contains four types of pixels: Red, Green, Blue, or Black.
The second chained recolors everything:
The black parts are made dark green with the constant weights.
The red parts are made black by negating the constant weights.
The green parts are made that yellow-green color by the additional weights from the Green channel.
The blue parts are made brown by the additional weights from the Blue channel.
Island Group
CodePen Embed Fallback
This example is basically a heightmap. It’s pretty easy to produce a realistic looking heightmap with — we only need to focus on one color channel and we already have it. Let’s focus on the Red channel. With the help of a , we turn the colorful noise into a grayscale heightmap by overwriting the Green and Blue channels with the value of the Red channel.
Now we can rely on the same value for each color channel per pixel. This makes it easy to recolor our image level-by-level with the help of , although, this time, we use a table type of function. table is similar to discrete, but each step is a ramp to the next step. This allows for a much smoother transition between levels.
The RGB transfer functions defined in
The number of tableValues determine how many ramps are in the transfer function. We have to consider two things to find the optimal number of ramps. One is the distribution of intensity in the image. The different intensities are unevenly distributed, although the ramp widths are always equal. The other thing to consider is the number of levels we would like to see. And, of course, we also need to remember that we are in linearized RGB space. We could get into the maths of all these, but it’s much easier to just play around and feel out the right values.
Mapping grayscale to colors with
We use deep blue and aqua color values from the lowest intensities to somewhere in the middle to represent the water. Then, we use a few flavors of yellow for the sandy parts. Finally, green and dark green at the highest intensities create the forest.
We haven’t seen the seed attribute in any these examples, but I invite you to try it out by adding it in there. Think of a random number between 1 and 10 million, then use that number as the seed attribute value in , like <feTurbulence seed="3761593"... >
Now you have your own variation of the pattern!
Production use
So far, what we’ve done is look at a bunch of cool SVG patterns and how they’re made. A lot of what we’ve seen is great proof-of-concept, but the real benefit is being able to use the patterns in production in a responsible way.
The way I see it, there are three fundamental paths to choose from.
Method 1: Using an inline data URI in CSS or HTML
My favorite way to use SVGs is to inline them, provided they are small enough. For me, “small enough” means a few kilobytes or less, but it really depends on the particular use case. The upside of inlining is that the image is guaranteed to be there in your CSS or HTML file, meaning there is no need to wait until it is downloaded.
The downside is having to encode the markup. Fortunately, there are some great tools made just for this purpose. Yoksel’s URL-encoder for SVG is one such tool that provides a copy-paste way UI to generate the code. If you’re looking for a programmatic approach — like as part of a build process — I suggest looking into mini-svg-data-uri. I haven’t used it personally, but it seems quite popular.
Regardless of the approach, the encoded data URI goes right in your CSS or HTML (or even JavaScript). CSS is better because of its reusability, but HTML has minimal delivery time. If you are using some sort of server-side rendering technique, you can also slip a randomized seed value in within the data URI to show a unique variation for each user.
Here’s the Starry Sky example used as a background image with its inline data URI in CSS:
It’s a super simple approach, but carries a huge drawback — especially with the examples we’ve seen.
That drawback? ID collision.
Notice that the SVG markup uses a #filter ID. Imagine adding the other examples in the same HTML file. If they also use a #filter ID, then that would cause the IDs to collide where the first instance overrides the others.
Personally, I would only use this technique in hand-crafted pages where the scope is small enough to be aware of all the included SVGs and their IDs. There’s the option of generating unique IDs during a build, but that’s a whole other story.
Method 3: Using a standalone SVG
This is the “classic” way to do SVG. In fact, it’s just like using any other image file. Drop the SVG file on a server, then use the URL in an HTML tag, or somewhere in CSS like a background image.
So, going back to the Starry Sky example. Here’s the contents of the SVG file again, but this time the file itself goes on the server.
Considering today’s HTTP2 support and how relatively small SVG files are compared to raster images, this isn’t a bad solution at all. Alternatively, the file can be placed on a CDN for even better delivery. The benefit of having SVGs as separate files is that they can be cached in multiple layers.
Caveats
While I really enjoy crafting these little patterns, I also have to acknowledge some of their imperfections.
The most important imperfection is that they can pretty quickly create a computationally heavy “monster” filter chain. The individual filter effects are very similar to one-off operations in photo editing software. We are basically “photoshopping” with code, and every time the browser displays this sort of SVG, it has to render each operation. So, if you end up having a long filter chain, you might be better off capturing and serving your result as a JPEG or PNG to save users CPU time. Taylor Hunt’s “Improving SVG Runtime Performance” has a lot of other great tips for getting the most performance out of SVG.
Secondly, we’ve got to talk about browser support. Generally speaking, SVG is well-supported, especially in modern browsers. However, I came across one issue with Safari when working with these patterns. I tried creating a repeating circular pattern using with spreadMethod="repeat". It worked well in Chrome and Firefox, but Safari wasn’t happy with it. Safari displays the radial gradient as if its spreadMethod was set to pad. You can verify it right in MDN’s documentation.
You may get different browsers rendering the same SVG differently. Considering all the complexities of rendering SVG, it’s pretty hard to achieve perfect consistency. That said, I have only found one difference between the browsers that’s worth mentioning and it’s when switching to “full screen” view. When Firefox goes full screen, it doesn’t render the SVG in the extended part of the viewport. Chrome and Safari are good though. You can verify it by opening this pen in your browser of choice, then going into full screen mode. It’s a rare edge-case that could probably be worked around with some JavaScript and the Fullscreen API.
Thanks!
Phew, that’s a wrap! We not only got to look at some cool patterns, but we learned a ton about in SVG, including the various filters it takes and how to manipulate them in interesting ways.
Like most things on the web, there are downsides and potential drawbacks to the concepts we covered together, but hopefully you now have a sense of what’s possible and what to watch for. You have the power to create some awesome patterns in SVG!
A key part of designing successful websites for clients is making sure that as many end-users as possible can access and enjoy that site.
So, what if you discovered that around 1 billion people couldn’t enjoy your designs? Even if those people manage to click on a link and visit the website that you create, they might not be able to understand what’s being sold or navigate to the checkout page.
According to statistics from the World Bank, there are 1 billion people with disabilities worldwide. That’s 15% of the total population of the globe.
Despite this, many designers fail to consider customers with differing abilities when creating an engaging app or website. Unless your client explicitly tells you that they’re supporting customers with disabilities, you might even not think about those users at all.
Learning how to embrace the concept of inclusive web design means that you deliver better results to your clients; the more customers your clients can reach, the more praise and positive reviews your designs will get.
So, how do you introduce accessibility in your design choices?
What Is Website Accessibility?
In broad terms, inclusivity refers to activities or behaviors that empower marginalized people in society. Designing for inclusivity means making your content more accessible to anyone dealing with a mental or physical issue that may make it harder for them to use a traditional site.
Ultimately, accessibility is one of the main goals of an inclusive design strategy. When you make websites or applications more accessible, you tweak aspects of your UI and code to make the site as approachable and usable as possible to people with certain limitations.
According to the Web Accessibility Initiative, many modern sites and web tools are designed without the needs of those with disabilities in mind. This creates accessibility barriers that make websites almost impossible for some people to use.
Here are just some of the different types of disability that can affect the way end-users interact with a website or app:
Cognitive issues: Affecting understanding and making it harder to navigate sites;
Auditory issues: Preventing customers from listening to videos and audio content;
Neurological issues: Making certain terms and actions more difficult on your site;
Physical issues: Making it hard to swipe or tap certain tools;
Speech problems: A common issue with voice UI designs;
Visual issues: Preventing a positive experience on highly visual sites.
Web accessibility can also be about making life easier for people who encounter problems in particular situations. For instance, those with muscular problems might have a harder time using buttons and links on a small screen.
So, how do you make your designs more accessible?
Know Your Audience
There’s more to inclusive web design than making your fonts a little bigger and hoping for the best. To deliver a truly accessible experience, you need to know the people and groups that your client is targeting. Spending some time going through your customer’s user personas and asking them questions about those with a disability can help you make informed decisions.
For instance, the Microsoft Inclusive Design toolkit asks designers to recognize exclusion, examining the parts of their website that might be inaccessible, and learn from diversity.
Before designing anything, ask yourself whether you can:
Address any unique needs, like sight issues or hearing problems;
Replace traditional solutions with something more unique. For instance, rather than relying on colors to highlight a portion of text, could you use font-weight instead? This might be ideal for someone with color blindness;
Create something that appeals to both customers with and without disabilities.
Design a Clean and Clear Layout
Any website design should be focused on clarity first.
Whether you’re designing for inclusivity or not, the aim should be to deliver as much of a simple and straightforward experience as possible, avoiding any web design sins along the way.
For instance, no-one likes a messy design full of unreasonable navigational signs. You need a site full of understandable links, buttons that are easy to click on any screen, and large fonts that are easy to read.
Whenever you’re creating a new element for a website or app, ask yourself how you can make life easier for customers from all backgrounds. For instance, Parramatta park uses excellent contrast, clear fonts, and ideal element sizing to ensure that its website feels as easy to use as possible for customers.
Notice how the buttons are clear and easy to press. The colors are bright and engaging on any screen, and the navigation is simple to follow too. Remember, when you’re designing an inclusive prototype:
Test navigation options and ensure they’re easy to use;
Don’t overcrowd the screen, remember that less is more when reducing cognitive load;
The visual elements on an inclusive website need to be as simple and easy to understand as possible. However, it’s important not to forget about the way that you handle the written word too.
Using simple terms instead of complex industry jargon can make a massive difference to those with reading issues. There’s also typography to think about, from the color and contrast of your words against your chosen background to the font’s clarity.
Remember, suboptimal design with both imagery and language affects those without disabilities too. Following basic rules for simplicity delivers a better experience for anyone that visits your site.
Make sure you:
Underline, bold, or re-size links for visual contrast;
Enforce proper line spacing with around 1.5x the font size;
Enable consistent paragraph spacing;
Use simple language to reduce cognitive load;
Describe abbreviations when using them;
Use clearly-worded headings to structure content logically;
Look at the design choices for text on the Nomensa website, for instance. Plenty of white space makes content easier to read. Simple words are understandable and engaging. Even the font choice mimics the logo while offering readability.
Optimize Web Design Colors
Inclusive web design trends will come and go. However, color and contrast will always be essential to your decisions.
By making sure that your design elements meet the minimum color contrast ratios defined by the WCAG means that you’re supporting readability for visually-impaired users and improving experiences for customers that aren’t visually impaired as well.
For designers who need extra help in this area, tools like Stark help measure color contrast. This tool also offers a range of other tools intended to support accessibility too.
Remember, the minimum ratio you need to access will depend on the element that you’re designing. The WCAG recommends the following guidelines:
3:1 ratio for graphical objects (charts);
3:1 ratio for focus, active states, and hover;
3:1 ratio for clickable items and form components.
While you’re working on your color contrast strategies with apps like Stark, make sure that you consider the needs of users with color blindness too. 4.5% of the world doesn’t see color the same way as everyone else. If you’re finding it difficult to achieve the right contrast while sticking to your customer’s brand guidelines, try underlining and bolding elements too.
Consider Video and Audio Elements
Finally, these days, more companies are opting to embed video and audio content into their sites. These visual and auditory tools can offer useful information about a brand and what it does. However, you could struggle to deliver vital information to some customers through video and audio alone.
Captions for video content could be essential for those with hearing loss. You may need to think about adding transcripts to pre-recorded videos that people with hearing impairments can access. These transcripts and captions are also helpful for anyone who doesn’t have access to audio on smartphones or computers.
Transcripts can also help those with visual impairments by giving a text-to-speech tool something to describe to your user. That way, everyone gains useful information. Look at this captioned video from the University of Washington, for instance. It ensures that everyone can understand what’s going on in the content. If you add transcripts to your website pages for clients, you could also help them benefit from improved SEO too. Transcripts deliver more keyword-ranking opportunities than videos and podcasts on their own.
Design for Accessibility First
For designers to excel at delivering truly inclusive UI environments, they need to become as good at creating websites for people with disabilities as they are at creating interfaces for people like themselves. As designers, we try to be as inclusive as possible, but it’s easy to get caught up thinking about making a website easier to use for us.
If you can step into the shoes of someone that isn’t like you, and think about uncommon needs first, then you may find that you deliver a stronger, more engaging experience for every user.
For instance, rather than designing a website for someone with the same visual needs as you, then thinking about making tweaks for those with color blindness or vision issues, think about the needs of those with disabilities first.
You can learn more about putting uncommon needs first by checking out Vasilis Van Gemert’s blog post on the “Method of Crisis.”
Accessibility is Good for Business
Inclusive web design, or designing for accessibility, is all about maximizing the potential audience that your clients can earn. Whatever situation end-users find themselves in, you should ensure that you’re taking advantage of inclusive design.
If you can prove to your clients that you can deliver for all customers’ needs, you can unlock a much larger audience and many more opportunities.
is the output channel value
are the input channel values
are the weights
to 
(the constant) to 
is the weight of Red channel’s contribution to the Red channel.
is the weight of Red channel’s contribution to the Green channel.
is the weight of Green channel’s contribution to the Red channel.
is the weight of Green channel’s contribution to the Green channel.
, 
, and 
. It might look odd at first, but there’s a good reason for using linearized RGB for some transformations. 
, 
in the first line and hit the 
