<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Konrad F on Medium]]></title>
        <description><![CDATA[Stories by Konrad F on Medium]]></description>
        <link>https://medium.com/@konradf?source=rss-69d79a9e269a------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*4GWem1Mfrrt-FlXkXADgNg.jpeg</url>
            <title>Stories by Konrad F on Medium</title>
            <link>https://medium.com/@konradf?source=rss-69d79a9e269a------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 19:00:06 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@konradf/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Icons 101: Not only for designers]]></title>
            <link>https://blog.prototypr.io/icons-101-not-only-for-designers-a2d7a24df610?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a2d7a24df610</guid>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[frontend]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[graphics]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Wed, 16 Nov 2022 16:34:17 GMT</pubDate>
            <atom:updated>2022-11-17T13:02:36.291Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="A photo of a screen displaying various icons." src="https://cdn-images-1.medium.com/max/1024/1*QCfwo28i9GMSGUdT5QxHMA.png" /></figure><p>This is not a how to create your first icon. This is a how to download an icon off the web and not break it.</p><p>Icons aren’t very complicated. They’re so simple in fact that many of us stop paying attention and ignore some very simple rules that everyone should respect when dealing with icons. Let’s dive in.</p><h4>Vector vs Bitmap</h4><p>Everybody knows this, but then you catch some sneaky developer exporting your vectors as PNGs while nobody’s looking. Bitmaps (most common formats include GIFs, JPGs, and PNGs) do not scale well. Scaling them up or down will decrease clarity and introduce blurriness. Unless there’s a very good reason to use them for icons in your product — don’t.</p><figure><img alt="A comparison of what happens to vector and bitmap icons when upscaled." src="https://cdn-images-1.medium.com/max/1024/1*-uGHlIG-ZE9kHahtOcDVWw.png" /></figure><p>Vectors on the other hand are created through the use of mathematical formulas, making them scaleable into any size you can imagine with no impact on their quality. The most common format in use is SVG.</p><p>SVG as a format can contain bitmaps or even mix bitmaps and vectors. Even if you’re a designer whose imagination knows no bounds, computers do. Exporting bitmap images to SVG will not make them scaleable without loss of visual fidelity and is considered a criminal offense in some regions of the world.</p><h4>Stroke vs Outline</h4><p>Sometimes you get these icon packs that use stroke instead of outline. Which is cool, as it makes them easily adjustable.</p><figure><img alt="A comparison of how upscalign and downscaling affects outlined and filled vectors." src="https://cdn-images-1.medium.com/max/1024/1*uLpk3sdCsiSwCSSTWKeY9A.png" /></figure><p>Should you convert to outline when you’re done adjusting? In most cases outline is the safer choice. You lose some flexibility, but once exported, the thickness of the lines easily scales along with the size of the icons. That’s one less thing to worry about during implementation.</p><h4>Containers</h4><p>Just like a painting needs a canvas that defines its boundaries, an icon needs its own space to exist. If the space isn’t defined by designers and respected by developers, all kinds of chaos will most likely ensue.</p><figure><img alt="Four icons of varying sizes." src="https://cdn-images-1.medium.com/max/1024/1*7mTsDEl52JQ7BI6VgKzORA.png" /></figure><p>Even if visual design is not your cup of tea and you interpret the world as lines of code, you should notice that the icons above vary in size.</p><p>That’s why the best practice is to place them inside square containers (or artboards). Most designers will know that having containers allows for optical adjustment of the center of each icon.</p><figure><img alt="Four icons. Each placed and centered optically within its container." src="https://cdn-images-1.medium.com/max/1024/1*LzQSSILVV7TfRgqeSoJs8Q.png" /></figure><p>What’s even more important than that is the fact that without these evenly sized, square containers bare vectors create all kinds of visual chaos when placed in layouts, because they affect the position of other objects — whether in your designs or in live products.</p><figure><img alt="A comparison of how icons without containers and icons with containers affect the position of automatically aligned labels." src="https://cdn-images-1.medium.com/max/1024/1*d1C6-RAuqzDvdOqdRF15Yw.png" /></figure><p>See the image above for an example of what could happen if you’re not careful. The spacing between the icons and the text is always the same, but because the icons vary in size horizontally, the text is not properly aligned.</p><p>The vertical alignment within each row is set to the top, which is apparent when comparing icons of largely varying sizes. When you’re dealing with icons of similar size, it might be harder to notice right away, but even tiny differences impact the overall reception of your design or implementation.</p><p>If you’re a designer, never pull vectors out of their containers. If you’re a developer, never export without containers. Let’s all work together to create more beautiful interfaces for everyone!</p><p>Do you run into other issues working with icons that I forgot to mention? Let me know in the comments section.</p><h4>Resources</h4><p>Feather, Simply beautiful open source icons — <a href="https://feathericons.com/">https://feathericons.com/</a><br>white paper photo — <a href="https://unsplash.com/photos/_zKxPsGOGKg">https://unsplash.com/photos/_zKxPsGOGKg</a></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a2d7a24df610" width="1" height="1" alt=""><hr><p><a href="https://blog.prototypr.io/icons-101-not-only-for-designers-a2d7a24df610">Icons 101: Not only for designers</a> was originally published in <a href="https://blog.prototypr.io/">Prototypr</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Figma: Grouping Things]]></title>
            <link>https://blog.prototypr.io/figma-grouping-things-5580117279af?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/5580117279af</guid>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[information-architecture]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[ux-design]]></category>
            <category><![CDATA[ux]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Thu, 07 Oct 2021 09:15:27 GMT</pubDate>
            <atom:updated>2021-10-07T14:02:53.143Z</atom:updated>
            <content:encoded><![CDATA[<h4>A quick look at the differences between groups, frames and components in Figma.</h4><figure><img alt="Cover image with some abstract shapes and the name of the article ‘Figma: Grouping Things.’" src="https://cdn-images-1.medium.com/max/1024/1*qJruW7W-cBa1b0QHZGqzDg.png" /></figure><p>It’s hard to imagine any project that doesn’t utilize some form of grouping objects together. Grouping helps you keep your files nice and tidy, and — even more importantly — allows for the creation of structures such as buttons, tiles, or entire pages. Figma lets you group things in various ways that may seem confusing, intimidating, and almost redundant at first. Let’s look at how groups differ from frames and how components come into all this. Let’s talk about the information architecture of the project files themselves.</p><h3>Groups</h3><p>The most basic way of grouping elements is, rather unsurprisingly, through the use of groups. A group is just as big as the sum of its visible elements. It can’t be any bigger or any smaller. Resizing it causes the objects inside to scale with it. The only properties a group can receive are position, dimensions, blending mode, and opacity; modifying fill, stroke or effects affects all objects inside.</p><h3>Regular Frames</h3><p>Frames are a step up from groups. They can exist by themselves, they can be freely resized, and assigned the same properties you could apply to any rectangular vector. The way objects inside a frame behave when it’s resized is dependent on each object’s individual constraints. To give you an example of what this means, imagine you can force objects to stretch with the frame or stick to the edge’s frame or its center. The settings are applied for the vertical and horizontal axis separately.</p><figure><img alt="Animation illustrating the difference between default constraints (left) and setting up custom ones (right) when resizing frames." src="https://cdn-images-1.medium.com/max/800/1*rSfUF0sv-P52Ki3BLno41g.gif" /><figcaption>The difference between default constraints (left) and setting up custom ones (right).</figcaption></figure><p>The fact that you can apply settings like fill to a frame and have the objects inside behave in a certain way is a huge improvement over groups. Imagine you were trying to construct a simple white text on a blue background button. You can either create a rectangle vector, drop a text object on top, and put them both in a group. If you were to do that in a frame, all you need is a text object inside a frame without the vector.</p><h3>Auto Layout Frames</h3><p>Auto Layout Frames are a relatively new addition to Figma’s repertoire. They too can be freely resized as well as assigned properties such as fill, stroke or effects. The thing that makes them very distinct from regular frames is how they handle objects inside — objects cannot be put on top of one another, the spacing between them has to be even, and they can only be put in a single row or a column (so you cannot have multiple rows or columns of objects unless you nest frames).</p><figure><img alt="Animation illustrating the various ways of handling objects inside horizontal and vertical auto layout frames." src="https://cdn-images-1.medium.com/max/800/1*DP7my59bZN0ZIK6Zdjl9hw.gif" /><figcaption>Different ways of handling objects inside horizontal and vertical auto layout frames.</figcaption></figure><p>While auto layout frames can exist without any objects inside, their main purpose is to automatically distribute objects that they contain, either horizontally or vertically. Check out <a href="https://uxdesign.cc/figmas-auto-layout-in-action-9ffb0b305a56">my article on auto layout frames in Figma</a> if you want to learn more.</p><h3>Regular vs Auto Layout Frame</h3><p>Now whether you should use regular or auto layout frames comes down to what effect you want to achieve. I’d argue that if you’re designing any layouts, 9 times out of 10, you should go with auto layout. When set up properly, auto layout groups will resize automatically as you change the contents or dimensions of the objects inside and will always make sure that all the paddings and spacings are nice and even without you having to take any measurements the old school way (yes, I know what you’re doing with that rectangle.) The only case where auto layout causes more harm than good are frames that hold icons, vector images, etc. You can find out more about how to use and where to use auto layout by checking out my article.</p><h3>Components</h3><p>Components are frames that, when copied, spawn instances (or children) instead of duplicates. What that means is that when you go back to the main or parent component and change its properties or its contents, it will affect the properties and contents of all its children. You can turn any object or a group of objects into a component. When a single object or a group of objects are turned into a component, they’re put inside a frame that’s just as big as all of the objects inside it. When a group is turned into a component, it is automatically converted into a frame. Since components are frames, either regular or auto layout ones, everything I’ve said about regular or auto layout frames applies to them as well.</p><p>When should you create a component? Whenever you’re going to be using the same object or the same group of objects in many different places. You should always start small and remember that nesting components and sometimes putting them together to create bigger components is a thing. It all depends on whether you’re going to be using the smaller components in many bigger ones.</p><p>Check out <a href="https://uxdesign.cc/simple-reusable-design-system-in-figma-a3a01236a7e3">my article on creating a simple, reusable design system in Figma</a> to learn more about how to utilize components.</p><h3>Making connections</h3><p>Personally, I never use groups for anything other than moving a bunch of elements around just to ungroup the quickly after or grouping together some temporary trash elements that I don’t want getting lost. How you use these tools is totally up to you and depends on many things like the size of the projects and what you want to achieve. My suggestion would be to stick to using frames, as they should provide you with the most flexibility. You can resize them independently of the objects inside, you can add fills, use different types of layout settings. In any case, it’s worth exploring all the available options Figma provides to be able to decide which one of them best suits your use case.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=5580117279af" width="1" height="1" alt=""><hr><p><a href="https://blog.prototypr.io/figma-grouping-things-5580117279af">Figma: Grouping Things</a> was originally published in <a href="https://blog.prototypr.io/">Prototypr</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Safari bottom bar business]]></title>
            <link>https://blog.prototypr.io/safari-bottom-bar-business-90afd9b874f5?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/90afd9b874f5</guid>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[mobile]]></category>
            <category><![CDATA[apple]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Wed, 07 Jul 2021 10:43:46 GMT</pubDate>
            <atom:updated>2021-07-08T10:54:27.107Z</atom:updated>
            <content:encoded><![CDATA[<h4>Apple has recently revealed the <a href="https://thenextweb.com/news/wwdc-2021-roundup">new features of iOS 15 at WWDC21</a>, among them the bottom address bar. Finally!</h4><figure><img alt="A photo of a person using the Safari mobile browser on their iPhone running iOS 15" src="https://cdn-images-1.medium.com/max/1024/1*wpH4UT9Mi3MtHXqg2s7Wbg.png" /><figcaption>Safari mobile browser on iOS 15 (<a href="https://developer.apple.com/videos/play/wwdc2021/10029/">source</a>)</figcaption></figure><p>If you’re a designer, you’ve probably seen an illustration like the one below in one form or another. Since people’s hands and mobile phones differ in size, it just gives you a general sense of what’s reachable, but the point is, the area at the top of the screen where address bars usually reside is always considered a no-go zone for our thumbs.</p><figure><img alt="An illustration depicing my reachability on the iPhone XS" src="https://cdn-images-1.medium.com/max/375/1*k1SL5vngzEnNiAq10-T1Vw.png" /><figcaption>My reachability on the iPhone XS (give or take a few millimeters)</figcaption></figure><p>It doesn’t really take a designer to know that there’s no way you can comfortably use a mobile browser with just one hand. And yet, for no other reason than: “welp, it’s always been this way”, we’ve been stuck contorting our palms in unspeakable ways, trying to reach the address bar with our stubby thumbs. If that’s not a bad user experience, I don’t know what is.</p><p>So why did it take so long? I believe this is a testament to how hard it is to get people to accept any kind of change, even if it’s a change for the better. If there’s one company with enough pull to introduce a big change like this, convince everyone that it’s good for them and have the competition follow suit, it’s Apple.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*kaRfOg88oNqSCNCaO1hUPQ.png" /><figcaption>iOS 14 and iOS 15 (on the right) Safari, both in light and dark modes</figcaption></figure><p>As expected, there’s already some push-back out there. Macworld’s Jason Cross begins his piece by boldly stating that <em>“nobody asked for an address bar at the bottom of the screen,”</em> and then goes on to argue that it’s a bad idea to move the address bar to the bottom, because <em>“it does more than just defy convention — it’s entirely different from all the browsers ever used by a billion people going back…forever.”</em></p><blockquote>Nobody asked for an address bar at the bottom of the screen. — <a href="https://www.macworld.com/article/350064/safari-ios-15-interface-address-bar-tab-groups-gestures-refresh.html">Macworld</a></blockquote><p>While Jason is correct in saying that it defies convention, I fail to see how that is a bad thing. There were a few outliers that allowed users to move the address bar to the bottom of the window. One of them was Opera before the switch to Google’s Blink rendering engine back in 2013. Its spiritual successor, Vivaldi — currently only available for desktop platforms and Android — features the same level of customizability.</p><p>Most importantly though it was Microsoft’s attempt at carving out a piece of the mobile operating system market, the Windows Phone, that brought us the first prominent mobile browser with the address bar at the very bottom of the screen, where it was nice and reachable. The rest of the operating seemed even more alien than the address bar placement, people did not like it, and so, as of 2015, Windows Phone is no more.</p><figure><img alt="Internet Explorer mobile browser on Windows Phone 8.1" src="https://cdn-images-1.medium.com/max/1024/1*YZOVE0Pe1a1cm1n03n-IHQ.jpeg" /><figcaption>Internet Explorer mobile browser on Windows Phone 8.1 (<a href="https://www.youtube.com/watch?v=aNs1uYl9h8M">source</a>)</figcaption></figure><p>Microsoft wasn’t the only company to toy with the idea of moving the address bar to the bottom. A couple of years ago Google made the feature optional as <a href="https://www.ghacks.net/2016/11/02/google-experimenting-with-bottom-url-bar-on-android/">one of its Chrome experiments</a>. The feature is no longer available, which leads me to believe it wasn’t a user favorite either.</p><figure><img alt="Chrome mobile browser on Android with the address bar at the bottom" src="https://cdn-images-1.medium.com/max/400/1*4aNhgeiT2b1VYBd3lPPaow.png" /><figcaption>Chrome mobile browser on Android with the address bar at the bottom (<a href="https://www.ghacks.net/2016/11/02/google-experimenting-with-bottom-url-bar-on-android/">source</a>)</figcaption></figure><p>One could argue though that creating such differences between mobile and desktop interfaces goes against what many companies, including Apple, have been trying to do. Which is — bridging the gap between desktop and mobile, and in the case of Apple, making the ecosystem coherent to a point where switching from a MacBook to an iPhone is relatively smooth and painless, even for less tech-savvy individuals.</p><p>Then again, maybe that’s a bit of a technological dead end that we’ve run ourselves into. It doesn’t make much of a difference whether the address bar sits at the top or bottom of the screen on devices used with both hands such as the iPad or laptops/desktops, since the interaction with the content on the screen is done through the use of an external controller like a mouse or a trackpad. In case of mobile devices however there are use cases that make the controls at the top of the window somewhat problematic or impossible at times.</p><p>Personally I believe that some compromises need to be made, as it is only natural that we look for ways to adapt our software interfaces to the context in which they’re being used. There are still quite a few things that you won’t be able to comfortably do when using the phone with just one hand, but I think that rethinking the way we use the browser is a good first step.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=90afd9b874f5" width="1" height="1" alt=""><hr><p><a href="https://blog.prototypr.io/safari-bottom-bar-business-90afd9b874f5">Safari bottom bar business</a> was originally published in <a href="https://blog.prototypr.io/">Prototypr</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Introduction to Figma’s interactive components]]></title>
            <link>https://medium.com/design-bootcamp/introduction-to-figmas-interactive-components-70f0affe42fd?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/70f0affe42fd</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[design]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Sun, 04 Apr 2021 23:56:45 GMT</pubDate>
            <atom:updated>2021-04-04T23:56:45.537Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6Vx0R8Fy-DH5-1xgGlAJXw.png" /></figure><p>While it’s always been possible to animate controls using Figma prototypes, it required some crazy workarounds and a ton of views to be created. With the new functionality, it’s super easy, and it allows you to create some pretty nifty interactive and animating prototypes. The key thing to understand is that you can animate elements within a frame without changing the state of the parent frame. You can make them react to user input or simply loop them.</p><p>There’s a certain limitation that needs to be kept in mind when dealing with the new feature. It only works within a single component. So for example, you wouldn’t be able to string together two variants that belong to separate components, and you can’t connect two separate components that exist by themselves (without any variants) for that matter. So in order to use this new functionality, you should be quite comfortable with using variants.</p><p>Now the first thing that comes to mind when thinking interactive elements in any given project are buttons, so let’s start there.</p><h4>Simple buttons</h4><p>Create a new component and turn it into a variant. Now add a new variant by clicking the + button inside the component group or just copy/paste the existing one and modify it, so that it looks like a hover state, and then do another one that’s going to be used when the button’s clicked.</p><p>It’s completely up to you how to style/design each state, the important thing here is to now connect the three states in a way that’s going to make the button interactive. In order to do that switch to the prototype tab and connect the default and the hover state. The default event for new connections is ‘On click’, so we need to go into settings and change it to ‘While hovering’. You should also change the animation type from ‘Instant’ to ‘Smart animate’ and voila. Now when you put the button (in its default state) in a frame and hover over it, it should animate. The next step is to connect the second state with the third one. For this connection between the second and the third state, we’re going to be using the ‘While pressing’ event type.</p><figure><img alt="A simple button component with three button states and interaction details popups." src="https://cdn-images-1.medium.com/max/700/1*JEDJ74cH_Pj_3zdOlNjIkg.png" /></figure><figure><img alt="An animation that shows how a green button animates when hovered over and pressed." src="https://cdn-images-1.medium.com/max/700/1*yEl36OrVrbJ2-kI7ZOzfpg.gif" /></figure><p>Naturally, you don’t need to limit yourself to animating shadow and color changes. You can animate pretty much anything you can think of. For our next example let’s use the underscored link that turns into a button on hover. The prototype settings look the same. The only difference is I’m animating the background (a rectangle) that changes its vertical size to fill out the frame on hover. I’m also using blend modes to have the text change its color based on what’s in the background.</p><figure><img alt="An animation that shows how an underscored link that turns into a button animates when hovered over and pressed." src="https://cdn-images-1.medium.com/max/700/1*5BCT665gWZDi8-63YJcI_w.gif" /></figure><h4>Not so simple buttons</h4><p>Simple, right? Let’s turn it up a notch. How about one of them submit/upload type buttons that change states and animate? We can use the previous button as the base for our next creation, only this time we’re going to need a few more variants inside of the component group. I’d like to have an icon that animates and informs me that the process of uploading is underway.</p><p>There are two ways of doing this. You could animate the whole thing by using many variants inside the button group and stringing them together through After Delay even types (that’s hardly English, but I hope you know what I mean). Or you could do it properly and embed a prototype inside a prototype to make it loop, or in other words, use an animated icon. This is what we’re going to do since this method allows for much more flexibility and reuse of the icon.</p><h4>Perpetual loops</h4><p>First, you’re going to need another component that animates and loops. As long as you put it anywhere inside a frame and run the whole thing as a prototype, it’ll keep going through its motions until the end of time or at least the end of your laptop’s battery. Let’s do a basic spinning circle (or a 270-degree circular arc to be exact).</p><p>Animating circles in Figma requires some gymnastics. You can’t just tell them to rotate. You need two additional states: the first one at -179 degrees, the second one at 180. Another tricky part is making this thing loop. We’re going to set the default state to switch to the second state after a delay of 1ms with the transition taking 500ms in a linear fashion. Since the difference in rotation between the second and the third state is so tiny, the transition needs to be pretty much instantaneous. Lastly, in order to close the loop, we need to connect the third state with the first one and use the same settings as we did between the first and second states.</p><figure><img alt="A looped animation component and interaction details popups." src="https://cdn-images-1.medium.com/max/700/1*Upz83SUC20gDEr3cKUIQuA.png" /></figure><p>So this is how you put animations in a perpetual loop. You can do the same thing with any kind of animation that you’d like to use inside your Figma prototypes.</p><p>Now let’s go back and finish the button. We can use one of our previous buttons as a base for this one. For this, we need five states: default, hover, clicked, busy, finished.</p><figure><img alt="A more complicated button component with several button states and interaction between each of them described." src="https://cdn-images-1.medium.com/max/700/1*bNmqEfXtRxAombPWi3cxFg.png" /></figure><p>Now the first event happens while you’re hovering over the object. The second one needs to be an On click event. The reason for that is that previously we just wanted to show how the button reacts to clicks. Now we want the button to move to the next state once the button is pressed, independently of what the user does next. That’s why the third state automatically moves to the fourth state after the smallest possible delay and that is when we get to see the looped animation in all its glory. The fourth state is when the aforementioned flexibility comes into play. The animated circle will loop for as long as we like. I’ve decided to loop it for 2 seconds, that is why the After delay is set to 2000ms. The fifth state is invoked automatically after said delay and that’s where our button’s animated journey ends.</p><figure><img alt="The end result of the upload button." src="https://cdn-images-1.medium.com/max/700/1*FF9Gx5KXQpT7hwUPLXYoTw.gif" /></figure><h4>Practical uses</h4><p>Aside from making your prototypes just a tad more fab, this new functionality allows you to set up what you might call an interaction library for yourself and your developers. With all the interactive elements that your app uses grouped, it could serve as part of your documentation. Its usage is not limited to buttons of course. You can animate all sorts of controls and the things you can do are only limited by your imagination and the amount of time you have for these sorts of shenanigans. Good luck.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=70f0affe42fd" width="1" height="1" alt=""><hr><p><a href="https://medium.com/design-bootcamp/introduction-to-figmas-interactive-components-70f0affe42fd">Introduction to Figma’s interactive components</a> was originally published in <a href="https://medium.com/design-bootcamp">Bootcamp</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Figma’s Auto Layout in action]]></title>
            <link>https://uxdesign.cc/figmas-auto-layout-in-action-9ffb0b305a56?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/9ffb0b305a56</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[ui-design]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[prototyping]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Wed, 16 Dec 2020 23:12:38 GMT</pubDate>
            <atom:updated>2020-12-16T23:45:51.007Z</atom:updated>
            <content:encoded><![CDATA[<h4>Part 2</h4><h4>Figma has recently upgraded its Auto Layout feature and as you probably already know, it is glorious. Let me show you why.</h4><figure><img alt="Cover image with text that says Figma’s Auto Layout in Action Part 2" src="https://cdn-images-1.medium.com/max/1024/1*yF6V-J7nqvCNVhpu8p5JLw.jpeg" /></figure><p><strong>Since the introduction of this new functionality,</strong> I’ve almost entirely moved away from using regular frames. While the Auto Layout <a href="https://uxdesign.cc/figmas-auto-layout-in-action-d84c4688aca4">I did an article on a while back</a> was pretty neat, it couldn’t replace the regular frames. There are very few things that the new Auto Layout cannot do, and designing libraries of freely resizable and — mostly importantly — truly responsive elements that can be used across many different screen sizes has been brought to a whole another level.</p><p>Let’s look at a simple grocery delivery type app, how Auto Layout can be used to put its interface together.</p><p>There are some cases where setting the mainframe of a screen to Auto Layout (AL) would make sense, but most of the time you’re going to want to avoid it. Most importantly, you can’t use fixed elements in an AL frame. Another case where using AL wouldn’t be entirely feasible is when you’d have a lot of empty space, for example when displaying only a single element in a list, forcing you to use spacers or something — not a clean solution.</p><figure><img alt="Layers section view displaying the structure of the Main Frame and its subframes" src="https://cdn-images-1.medium.com/max/700/1*JbMczM15QKC3YMK0Esrtjw.jpeg" /></figure><p>Save for some very specific cases, where using AL for the Main Frame makes sense, the way I like to do things (especially for mobile) is have two container frames inside the Main Frame, where one is fixed. The Main Frame is going to have to be resized manually in case you want to put more stuff in it, but having the inner container hug items is going to help you with that thanks to snapping. The Fixed Container has to retain its original dimensions, so it should have its width as well as height set to fixed. The normal container is set to fixed size horizontally and — as I’ve already mentioned — hug vertically.</p><p>The downside of using this solution is that there’s no way to have the child elements adhere to the size of their parent (main) frame, as you can’t use the fill container property unless the container (parent frame) uses AL as well. At the same time, you can only use the scale property on frames that don’t use AL.</p><p>Now, since we’re not using AL for the Main Frame and using fixed horizontal sizing for the inner frames, you could ask me, “Konrad, why don’t we save ourselves some trouble and create margins by making the container frames a little smaller and constrained to the center?”. Well, that’s entirely up to you. If you’re going to be using any elements that might be filling up the screen in its entirety at least in one axis, it’s best to only use padding on those elements that explicitly require it.</p><figure><img alt="Iphone X mockup showing the finished layout of the demo application" src="https://cdn-images-1.medium.com/max/700/1*vybCkqrchNI6wzIQeZaxjg.jpeg" /></figure><p>In order to have our design looking somewhat like the one above, let’s take care of the fixed frame first. In the case of this particular screen it’s comprised of 3 sub-frames. Top to bottom, the iOS Status Bar, the app’s Nav Bar and the bottom Home Indicator.</p><figure><img alt="Layout showing what the frames inside the fixed container will look like." src="https://cdn-images-1.medium.com/max/700/1*ZM3fTP9BFP26w2AbNm15aA.jpeg" /></figure><p>The iOS status bar I’m using comes from a kit, and if I wanted to make the items equally sized and spaced out, it’d break the entire design. Using AL is not necessary for this frame. You can just constrain the elements to left and right appropriately and then set the frame to stretch. If you’re set on going full AL, go ahead and put the elements on the left and right in two separate, non-AL frames and expand the frames while holding CMND or CTRL to fill the extreme edges of the parent frame. Now set the items to Space Around from the AL settings dropdown.</p><figure><img alt="View of the iOS status bar frame explaing how AL can be used with it." src="https://cdn-images-1.medium.com/max/700/1*TqjJk_owjMZ8wNvxgaRgsA.jpeg" /></figure><p>The Nav Bar is simple. It uses 32x32px icons, so all we need to do is set it to AL, then set the padding (let’s say 32px as well), and Space Around from the dropdown.</p><p>The Home Indicator only houses a single item and really doesn’t need AL, so we’re going to constrain the bar to bottom center and leave it at that.</p><figure><img alt="Layers section view displaying the structure of the Fixed Container frame and its child frames." src="https://cdn-images-1.medium.com/max/700/1*J8JkYxbzs40W_eCFWvRK7A.jpeg" /></figure><p>Now what we’re going to do is try and create a structure as shown in the example above. The regular Container is empty for now, so let’s focus on the Fixed Container frame.</p><p>The items in the Layers section are ordered from the bottom up, which means that the item order of objects here will be inversely analogous to their visual order when using vertical AL. That’s why the first child element of the Fixed Container is the Home Indicator frame. The second element is the Top frame, which I haven’t told you about just yet. I want two of the frames to stick to the top and one of them to the bottom of the container.</p><figure><img alt="Comparison of 3 elements inside an AL frame with space around property on on the left and 2 elements on the right." src="https://cdn-images-1.medium.com/max/830/1*26DIKXNuNX6AkqfzbyUs7Q.jpeg" /></figure><p>When spaced around they’ll take up the maximum possible space in their container while spaced around evenly (as shown in the example on the left, above). That’s why we want two of the frames that are supposed to sit in the top section of the container inside another container called Top, inside which child-frames are packed with no spacing between them. Now the Top frame and the Bottom Indicator frame can be spaced around, so we always use up the maximum amount of space inside the container without having to adjust the position of child elements manually if we were to add something there.</p><figure><img alt="A comparison view explaining what the regular container’s structure looks like." src="https://cdn-images-1.medium.com/max/830/1*f_jqolQxUi7lluJgFbm_KQ.jpeg" /></figure><p>Now that we’re done setting up the fixed container we can safely lock it, so it doesn’t interfere with the regular container frame and its contents while we’re working on them. The above example shows you what the insides of the regular container frame look like. Even though there’s a lot of elements we need two elements in it, the image that I’ve decided is going to fill the screen horizontally without any padding (even though you can’t see that, as its background is white) and a frame that for the purpose of this demo I’ve decided to name Everything Else.</p><figure><img alt="Layers section view displaying the structure of the Everything Else frame." src="https://cdn-images-1.medium.com/max/700/1*XV8IbuW_Vdpd-YC5OoIgVw.jpeg" /></figure><p>So as you can see it’s all a series of AL frames, which might seem a little intimidating at first. Each frame’s role is to position its child elements in a certain way.</p><p>And so the Description houses the headline and the paragraph explaining to you in some detail what the White Dragon Fruit is all about. Just like every other frame, this one is also set up so that you can safely modify its contents without breaking the entire layout. It’s set to fill its parent frame (Everything else) horizontally and hug the contents vertically, which means it’ll get just as big as it needs to be. The headline and the paragraph text layers inside are set up exactly the same way, which is synonymous with setting their property to Auto Height.</p><p>As you move up you notice the Price &amp; Amount frame which again breaks down into two separate frames — one for the Price and another one for the Amount. The frame is set to fill the parent frame, while its child frames are set to space around. The Price frame contains two text objects packed vertically and aligned to the right. It hugs its contents in both dimensions. The amount frame uses a different background, there’s’ 24px of space between elements, they’re packed, aligned to the center-middle (this is actually important in this case, as the text object is only 24px while the icons are 32px tall, and the padding inside the Amount frame is set to 8, 16, 8, 16 starting from the top and going clockwise.</p><p>The button is just a button, no surprises there. It is set to fill the frame horizontally and its height is fixed to 56px.</p><p>“What manner of devilry is this?” You might inquire upon noticing that the Price History AL frame has some of its elements aligned to the left, and some of them to the right. As with most things, there are at least two ways we can approach this. One is to set the alignment of everything inside the frame to right (vertical alignment is irrelevant), have the text layer (the headline) fill the frame, and set the alignment of the text inside the text layer to the left. That way the text object is right-aligned, even though it doesn’t really matter, since it’s filling up the entirety of the space anyway, but the actual text inside the text object is aligned left. You can also do this the other way around. Align everything inside the Price History AL frame to the left, set the Period frame to fill its parent frame, and set the alignment of the Period frame’s elements to the right. There’s not much to talk about when it comes to the line graph, you actually need a regular frame to construct that thing.</p><figure><img alt="A comparison view explaining the structure of the Everything Else AL frame." src="https://cdn-images-1.medium.com/max/830/1*TFGrGWzWQJp1AIz0Hsv1Fw.jpeg" /></figure><p>At the beginning of the article, I’ve mentioned that the new AL makes the frames that utilize it truly responsive, which makes it possible for them to be used across many different devices. What’s even more important than that is the fact that having your design held inside containers that automatically put spaces between makes it so much easier to deliver pixel-perfect design, where you don’t even have to worry about snapping anymore. Not only does it make your designs that much cleaner, but it also makes them much easier to update, expand, edit, etc. everywhere where components simply aren’t viable, without having to resize and move everything around when you add an icon or a menu entry.</p><p>There are many other cases where this functionality comes in handy, and there are tons of things that I haven’t covered in the article, but I’m hoping that this should set you on the right path and give you at least some idea of what can be done with Auto Layout in Figma. Good luck.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/94/0*NMdNk8MG3AaSL2mY" /><figcaption>The UX Collective donates US$1 for each article published on our platform. This story contributed to <a href="https://www.bayareablackdesigners.com/">Bay Area Black Designers</a>: a professional development community for Black people who are digital designers and researchers in the San Francisco Bay Area. By joining together in community, members share inspiration, connection, peer mentorship, professional development, resources, feedback, support, and resilience. Silence against systemic racism is not an option. Build the design community you believe in.</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=9ffb0b305a56" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/figmas-auto-layout-in-action-9ffb0b305a56">Figma’s Auto Layout in action</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Advanced Image Manipulation in Figma]]></title>
            <link>https://uxdesign.cc/advanced-image-manipulation-in-figma-e1a0468c4982?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/e1a0468c4982</guid>
            <category><![CDATA[graphic-design]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[visual-design]]></category>
            <category><![CDATA[figma]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Wed, 15 Jul 2020 23:26:30 GMT</pubDate>
            <atom:updated>2020-07-15T23:26:30.916Z</atom:updated>
            <content:encoded><![CDATA[<h3>Advanced image manipulation in Figma</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bnPkViGBqFuBLV968CogfA.jpeg" /></figure><p>Figma is not exactly suited for image manipulation, and that’s completely fine. While it does provide an ample amount of tools that let you apply some basic changes to your raster images, for anything more complex you need to look someplace else. Unless of course you’re really stubborn, like me, and enjoy doing things the hard way.</p><h3>The basics</h3><p>Now let’s quickly cover the basics of what you can do. First, you have the set of slider controls anyone who’s modified a photo on their phone should be familiar with.</p><figure><img alt="Basic image modification sliders in Figma and their effects" src="https://cdn-images-1.medium.com/max/700/1*fct4d4y942TS018He27pKg.jpeg" /></figure><p>Figma also provides you with the blend mode feature, used to determine how two layers interact with each other. Well known to those of us who have used Photoshop or similar apps in the past. Blend modes are a great feature, but using them properly may require a lot of practice and experimentation.</p><figure><img alt="Dark gray, red, blue and light gray layers over an image with different blend mode settings" src="https://cdn-images-1.medium.com/max/700/1*fnrFuvEqQhQXX0zRCozHcQ.jpeg" /></figure><p>You also get to choose how an image behaves when it’s resized, or rather when its bounding area is resized. This should make the most sense to those who are not afraid to dabble in CSS.</p><p>The default option for an image is to fill its bounding area. What this means is that when it’s scaled up or down and the image no longer fits the bounding area, some of its parts will get cropped away or rather hidden from view.</p><p>The second option is fit. The image always remains in full view and is centered inside the bounding area. If the bounding area is too wide or too tall, you’ll get some empty space on the sides of an image.</p><figure><img alt="Image settings popup in Figma and some of the available controls described" src="https://cdn-images-1.medium.com/max/920/1*2pi5ilFOUFqTYmcB6CMcpw.jpeg" /></figure><p>Crop seems a little janky, I rarely use it. When you choose crop from the menu, you get these handles that allow you to specify the bounding area. Even though the X, Y, W &amp; H properties change accordingly when you manipulate the bounding area with your mouse, you can’t use them to define its exact size or location. As soon as you click either of those controls you get kicked out of the crop mode. Thankfully snapping still works. You have to be careful after using crop mode, as the image will lose its aspect ratio (as shown in the example below) when the bounding area is resized without the shift key being pressed.</p><p>Using tile for the first time brings the image to its original aspect ratio and size. If the bounding area’s smaller then the original image, you won’t see the effect of tiling. You can modify the size of the tile by setting its size in percentages or grabbing the side of a tile and moving it around. The tiles always retain the aspect ratio of the original image. This is a great tool for generating pattern backgrounds.</p><figure><img alt="Fill, fit, crop and tile settings and their effects" src="https://cdn-images-1.medium.com/max/700/1*t2Z6pII7MSxEkTT2pgxemA.jpeg" /></figure><p>All of these changes can be reversed, although there’s no quick way to bring back an image to its original size and properties. You could delete the modified image and reimport it, but that’d be way too easy. What any self-respecting Figma aficionado should do is set the image to tile. That’ll make the image pop back to its original size (or if you’ve been using tile before on the image, just set the tile size to 100%) and aspect ratio. Now resize the bounding box to fit the image’s frame and there you go.</p><h3>Fill layer stacking</h3><p>Now that we’ve got all the obvious stuff out of the way, it’s time to move on to the fun parts. One of the coolest and less known features is the ability to stack fill layers of an object. It’s kind of like nesting layers inside an object or even a separate system of layers that behaves pretty much as the normal layers do.</p><figure><img alt="Adding new property or setting layers to fill, stroke, effect and export in Figma" src="https://cdn-images-1.medium.com/max/700/1*2olIMGwPDLbVQhk_r3ocjw.jpeg" /></figure><p>You can have multiple fill layers, stroke layers, effect layers or export settings. Since we’re talking about image modification, we’re going to be talking about fill exclusively. Clicking the + button more than once keeps adding additional fill layers. The default type setting for the second fill layer, regardless of what kind of fill layer is set as the first one, is gradient.</p><p>This is really cool because you can exercise greater control over your imported images while keeping your regular layer structure clean. Normally you’d need to put the image object in a frame and have the effects in a separate object, all of them appropriately constrained. By stacking fill layers you keep all your effect layers inside one single object and you don’t need to worry about constraints.</p><figure><img alt="Grabbable area of fill layers" src="https://cdn-images-1.medium.com/max/700/1*-hNyjnHN8-wtJShIHZ-y6w.jpeg" /></figure><p>Just as with normal layers, you can change the stack order of your fill layers. All you have to do is grab one and move it to wherever you like. The tricky part is actually grabbing one. The example on the left (above) highlights the entire area of a single fill layer in the Fill panel and from left to right you’ve got four controls that let you set fill type and color, opacity or remove the layer. Everything that isn’t a control is grabbable (highlighted on the right) and allows you to move the layer around. Knowing all that you can go all kinds of crazy with overlay tints, gradients and blend modes to receive many satisfying or unsatisfying effects, but there’s more.</p><p>Once you have a fill layer selected you can copy it, but only through keyboard shortcuts. There’s no right click menu for this layer system in case you’re wondering. Since you’re copying a property rather than an object, you need to select an object or a set of objects in order to be able to paste your fill layer into. And this is actually pretty awesome, because it lets you copy a fill layer from an imported image and paste it into any object that accepts fill layers. It could be a circle (if you’re creating, say, an avatar) or it could be text. This action doesn’t overwrite any preexisting layers — it gets added as the topmost layer of an object.</p><figure><img alt="How copying fill layers can help you create avatars" src="https://cdn-images-1.medium.com/max/920/1*er4ww2S3BR2pqE431rE5CQ.jpeg" /></figure><p>This is different than using the more fleshed out method of copying properties of an object. When you’re doing that you’re copying a set of different properties — could be a lot of them. Using my method you can be very particular about choosing the properties you want to copy between two objects.</p><h3>Images as styles</h3><p>Some of the features I’ve described seem so obscure and unintuitive to use, it almost makes me questions their intendedness. As I’ve mentioned before, you could achieve the same effects by using the normal system of layers, masks, and constraints, though I often find myself preferring the fill stacking method. One of the reasons for that is that you can turn a combination of fill layers that includes an image into a color style for your design system. Once you’re ready setting up your layer stack, just add it to your color styles and it’s now ready to be applied to any object that accepts colors. So yeah, nothing’s stopping you from using it as a stroke layer now.</p><p>I hope that this newly acquired knowledge will have you switching back to Photoshop a little less now. Good luck.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e1a0468c4982" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/advanced-image-manipulation-in-figma-e1a0468c4982">Advanced Image Manipulation in Figma</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Tales of Apple tiles and what could be improved]]></title>
            <link>https://uxdesign.cc/tales-of-apple-tiles-and-what-could-be-improved-932b7058b200?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/932b7058b200</guid>
            <category><![CDATA[user-experience]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[ios]]></category>
            <category><![CDATA[visual-design]]></category>
            <category><![CDATA[apple]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Tue, 14 Jul 2020 00:25:34 GMT</pubDate>
            <atom:updated>2020-07-15T16:00:32.703Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>The new features promised at </em><a href="https://developer.apple.com/wwdc20/"><em>WWDC2020</em></a><em> put a very big smile on my face. Not only because we’re partly getting rid of icons, but also because the widgets, as Apple calls them, very much remind me of Windows Phone’s Tiles.</em></h4><figure><img alt="Cover image displaying a photo of a Nokia running Windows Phone and an iPhone running iOS14." src="https://cdn-images-1.medium.com/max/1024/1*fVsbhedXEEkIPwhyf7qSDg.jpeg" /></figure><p>Even since I can remember I’ve always been curious about trying out all kinds of software, checking out different operating systems, and improving my own user experience through customizing them. Over the years I’ve had the opportunity to test all the major mobile operating systems out there, and learn about their intricacies. One of the OSes that I’ve tried is now long dead, but still holds a special place in my heart is Windows Phone.</p><p>I’m currently an iPhone user, and for at least the past two years before every WWDC I’ve been crossing my fingers and hoping for an announcement of some improvements to the way the home screen works. After so many years icons have become boring, and—even more importantly—the way we interact with our phones has changed so much over the years that the information presented to us on our home screens requires thorough rethinking.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2FZLyDvABxGF0%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3DZLyDvABxGF0&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2FZLyDvABxGF0%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/a85d32d72aa69f86e067ac8ccafcf79c/href">https://medium.com/media/a85d32d72aa69f86e067ac8ccafcf79c/href</a></iframe><p>I’m well aware that Android is the best place for home screen experiments, but even though I can choose from a large selection of launchers, often customize them the way I want, the problem that I have is that the rest of the OS remains the same, doesn’t play well visually with the way the launcher looks, and that — as a designer — I simply cannot accept.</p><p>After years of using Android phones, I’ve decided that visual coherence is more important to me than being able to change the way the information on the home screen is presented, and so I switched back to Apple about two years ago.</p><figure><img alt="Nokia running Windows Phone" src="https://cdn-images-1.medium.com/max/700/1*3K-2ZP6GqkGfppEOjBCmSw.jpeg" /><figcaption>Nokia Lumia running Windows Phone</figcaption></figure><p>Even though the newly introduced widgets look quite different than their counterparts in Windows Phone, I think the idea is pretty much the same. They’re structured in a grid, they come in a few different sizes, they provide you with a snippet of information from the app that they represent, you cannot interact with their content — tapping them opens an app.</p><p>One major gripe that I have with the way widget look in iOS 14 is the inconsistency. If I didn’t know any better, I’d guess that they come from different designers and developers. Android suffers from exactly the same issue, their widgets are completely all over the place. I know it’s not an easy job given that the information inside a widget needs to make sense in the context of its app, but if Microsoft’s managed somehow, I’m hoping Apple won’t drop the ball on this one and make some significant improvements in this area before iOS 14 goes stable.</p><figure><img alt="Home Screen in Windows Phone" src="https://cdn-images-1.medium.com/max/700/1*oFqT3Tgv2HDrgWuJfHYPGw.jpeg" /><figcaption>Windows Phone and its glorious home screen</figcaption></figure><p>What made Windows Phone’s home screen so amazing to me and so unique was the approach to displaying notifications. You’d get information about the number of unanswered calls inside your Phone tile, you’d see snippets of unread messages in your Messaging app tile, and so on. I do realize that it’s uniqueness was one of the reason for its downfall, yet I’m still hoping that we’ll eventually see some more changes done to how home screens work.</p><p>Another thing that I think was pretty great about Windows Phone was the animation. Microsoft’s designers, at least in the earlier days of Windows Phone, were very meticulous about how things moved around the phone screen in order to draw your attention to certain elements of the interface, and let your journey through consequent screens understandable and easily navigable. Apart from that every tile would behave in a certain way. The contact app tile, for example, contained a set of tiles that would rotate different contact images, the Photo app rotated your favorite photos, the calendar app rotated between current date and your upcoming appointments. It brought a lot of life to the screen and let you acquire a lot more info from a tiny portion of the screen than you normally would.</p><p>It might be a little hard to imagine what a lot of this really looked like, and there’s not a lot of good reviews that focused on the software side of things, but if your memory’s hazy or you haven’t had the chance to check out the Windows Phone OS on your own, be sure to watch the video I link to below.</p><iframe src="https://cdn.embedly.com/widgets/media.html?src=https%3A%2F%2Fwww.youtube.com%2Fembed%2F_YQHNuJxziU%3Ffeature%3Doembed&amp;display_name=YouTube&amp;url=https%3A%2F%2Fwww.youtube.com%2Fwatch%3Fv%3D_YQHNuJxziU&amp;image=https%3A%2F%2Fi.ytimg.com%2Fvi%2F_YQHNuJxziU%2Fhqdefault.jpg&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;type=text%2Fhtml&amp;schema=youtube" width="854" height="480" frameborder="0" scrolling="no"><a href="https://medium.com/media/ea74752c620512447148f5bbd0fec132/href">https://medium.com/media/ea74752c620512447148f5bbd0fec132/href</a></iframe><p>I’m kind of hoping that Apple will be headed in that direction, and that we’ll see a lot more widgets for their system apps in the future. I’m also hoping that this change will prompt other companies (well, company, there’s not a lot of competition in the mobile OS market, unfortunately) to slowly start moving away from icons and coming up with ways to design better home screens.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=932b7058b200" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/tales-of-apple-tiles-and-what-could-be-improved-932b7058b200">Tales of Apple tiles and what could be improved</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Figma’s Auto Layout in action]]></title>
            <link>https://uxdesign.cc/figmas-auto-layout-in-action-d84c4688aca4?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/d84c4688aca4</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[ui]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Tue, 02 Jun 2020 23:14:01 GMT</pubDate>
            <atom:updated>2020-06-03T07:54:03.986Z</atom:updated>
            <content:encoded><![CDATA[<h4>Auto Layout is an amazing feature, but does it get all your design problems solved? Let’s examine some actual use cases to see where it works best.</h4><figure><img alt="Figma’s Auto Layout in Action (cover image)" src="https://cdn-images-1.medium.com/max/1024/1*SPfj3Rq9HKnsQHZ0l3ALbQ.jpeg" /></figure><p>Figma’s Auto Layout has been around for a while, but not everyone’s aware of the benefits it brings. It doesn’t replace constraints, they’re still very much needed. The trick is to use the right feature where necessary. I want to show you how to combine components, constraints, and Auto Layout for the best results.</p><p>I threw together a screen for an Uber Eats inspired food delivery app and I’m going to tear it down to show you how you can use Auto Layout along with constraints and components to up your design game.</p><figure><img alt="App Prototype in Figma Mirror" src="https://cdn-images-1.medium.com/max/676/1*oON8BH-JOwxTu-JmVNHiMg.gif" /><figcaption><em>Prototype in Figma Mirror. A little drizzly today, don’t mind the droplets.</em></figcaption></figure><p>Most of you already know that, but for a word of introduction, what Auto Layout does is automatically arrange elements placed inside of a frame. These elements can be either arranged vertically or horizontally and you can set the spacing between individual elements as well as between the elements and the borders of the frame. Because of this can’t use constraints or place elements on top of one another in frames that use Auto Layout.</p><figure><img alt="Application screen displaying how inner frames are used" src="https://cdn-images-1.medium.com/max/1024/1*cyP6YRkbVVlO6Xp_dsN0oA.jpeg" /></figure><p>At the top-most level, these are the four separate elements that the screen/frame is comprised of.</p><ol><li>The header consists of four inner frames and uses Auto Layout. We’ll get to it later.</li><li>This is the headline element which is simply a left and bottom constrained text element inside a frame.</li><li>The content area frame is a little more complex. More on that later.</li><li>The bottom menu houses a top and horizontally stretched 375x1px light gray rectangle and a group of icons inside a frame that we’ll tackle a little later.</li></ol><p>The frame for the screen is a lot longer than shown in the example above so that the much longer content area can be scrollable. The header’s and the menu’s positions are fixed when scrolling, which is one of the reasons we can’t be using Auto Layout in this frame. The sections (2) and (3) have their constraints set to align to top and stick to the left and right edges so that if the frame was to be resized, they’d stick to their initial position and also fill out the screen horizontally the way they do now.</p><figure><img alt="One of the inner frames using Auto Layout" src="https://cdn-images-1.medium.com/max/1024/1*N3Ace8Tr5_OHmcejtV33Wg.jpeg" /></figure><p>Now let’s look at the header element. It’s comprised of another four frames and this is where Auto Layout comes into play. They’re arranged vertically and there’s no spacing between any of them or any of the borders of the frame.</p><ol><li>This is the typical status icon setup in iOS. This frame contains a group of elements locked inside a frame that is set centered both horizontally and vertically. The inner frame houses a left and center constrained text element and right and center constrained vector icons.</li><li>This frame contains a frame that again uses Auto Layout to take care of the elements inside of it — we’ll get to it later.</li><li>It’s just a simple spacer element, a frame that is 1px tall with a light gray background.</li><li>This frame contains a left and center aligned icon and a horizontally and vertically centered text element.</li></ol><p>Now since every frame I use in this project is a component, what this does is enable me to easily modify the content of the header element across many screens. I can now easily modify the height of all inner frames or add more inner frames.</p><p>I often use this type of structuring when designing menus. In one of the bigger projects I work on we often use popup menus with a set number of options. The master component includes all these available options, but since each child instance of the popup menu uses 3–4 options at most, I just hide all the unnecessary ones. This way I use the same component across the entire system and just hide/unhide whatever menu options I need on a given screen. This technique could be used the same way in case of the header above — you could include all types of header elements used anywhere in the app and just hide/unhide the ones you need on a given screen.</p><figure><img alt="Using Auto Layout in the content area frame" src="https://cdn-images-1.medium.com/max/1024/1*nWAt3p3wM2gosSycS2-9ag.jpeg" /></figure><p>The content area frame contains cards (in the case of this particular project there are 5 cards) that are arranged vertically. The cards are 345px wide, and the horizontal padding is set to 15. That’s because I’m designing with a specific screen size in mind. I might be adding more cards, but I won’t be changing the screen’s size to anything other than 375px wide. We also needed some spacing between the cards themselves, so I set it to 32px. All cards use the same parent component whose inner elements (the image, the title etc.) I later modify accordingly.</p><figure><img alt="Digging even deeper, Auto Layout in the card frame" src="https://cdn-images-1.medium.com/max/1024/1*KFcAeU0B0Afe_nI9WIheVg.jpeg" /></figure><p>The card element is another component that exploits the Auto Layout feature.</p><ol><li>This is the image frame. In case of an app like this you could set up a bunch of image components that you could then easily switch between. You could also set these images up as styles. Check out <a href="https://uxdesign.cc/simple-reusable-design-system-in-figma-a3a01236a7e3">my article on how to create a simple design system</a> to find out how.</li><li>The title &amp; delivery time frame consists of two elements — one aligned to left and center, the other one to right and center as well.</li><li>This Auto Laid out frame uses Auto Layout for the two tags inside that are also using Auto Layout themselves. I’ll focus on this particular element in a bit.</li></ol><p>Now again this kind of setup enables us to modify the contents of an individual card — modify, add or remove elements from it without negatively impacting the content area. Say your stakeholders decide it’d be a good idea to place a little description for every restaurant under its name, you just add a frame that houses a text element and you’re good to go — this design change is not only automatically populated to all your screen but also arranged according to the layout you’ve decided on.</p><figure><img alt="This is how tags are made with Auto Layout" src="https://cdn-images-1.medium.com/max/1024/1*dwME_yBaxnxPfCC0qha6tA.jpeg" /></figure><p>The tags use the type of Auto Layout structuring I talked about earlier. As shown above, both tags stem from the same master component. The master component contains all types of elements used in a tag. The icon (replacable) and 3 editable text elements. The visibility of these elements is then configured accordingly. This way if you decide to change the font styling, the colors or the border radius of a tag, all you need to do is modify the settings of only one component.</p><figure><img alt="One of my favorite examples of combining Auto Layout and constraints" src="https://cdn-images-1.medium.com/max/1024/1*MCp_11cSoLAYMWljiXK9Fw.jpeg" /></figure><p>This is one of my favorite examples of combining Auto Layout with constraints. At the top-most level, both frames contain a center-aligned frame. The center-aligned frames use Auto Layout to arrange elements they contain and depending on what’s going on inside, how many elements there are or how big they are, they expand or contract while retaining the correct position.</p><p>There are many other way to combine Auto Layout with constraints, especially at a more complex level, where you need to accommodate for screen size changes as well as any changes inside the frames, but this short article should give you a general idea of what can be done using the features Figma provides.</p><p>Do you use Auto Layout in your designs? Would you do any of the things differently? Let me know in the comments below.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=d84c4688aca4" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/figmas-auto-layout-in-action-d84c4688aca4">Figma’s Auto Layout in action</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Simple, reusable design system in Figma]]></title>
            <link>https://uxdesign.cc/simple-reusable-design-system-in-figma-a3a01236a7e3?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/a3a01236a7e3</guid>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[design]]></category>
            <category><![CDATA[figma]]></category>
            <category><![CDATA[ux]]></category>
            <category><![CDATA[design-systems]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Mon, 25 May 2020 18:28:01 GMT</pubDate>
            <atom:updated>2020-05-26T01:04:45.506Z</atom:updated>
            <content:encoded><![CDATA[<h4>Find out how to create a simple design system with a library of style and components that will help you jump-start all your projects.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ttfq4j8CbfLy039dxx4Ufg.jpeg" /></figure><p>Putting together a design system may seem like an unnecessary hassle. It’s often easier to jump straight into designing things without having to worry about styles, components, or libraries. Some might even argue that when it comes to smaller projects, creating a design system takes nearly as much time as designing the entire project, so why bother?</p><p>While it’s true creating a design system is an additional step in the design process, what’s also true is that, regardless of the size of the project, the first version of your project rarely gets accepted by the client. Depending on the size of the project as well as the severity of the changes, introducing them could take a lot of time.</p><p>So whether you’re designing huge platforms or small e-commerce websites, design systems could save you a lot of time in the long run. Instead of going through each and every view making sure that you’ve applied the new colors or fonts, you could just take a look at your styles and components, introduce all the necessary changes in a few clicks and automatically populate them to the entire project.</p><p>Not only does this save you time, but it also allows for more coherent design practices as you limit yourself to only using predefined styles and components.</p><p>Figma gives you the tools to create a simple, easily reusable design system. There are a few ways you could approach this, and I’m going to try and cover all of them. I’d also like to take you through the list of things you’ll need to build your very own basic design system, which you can then modify and grow to best suit your project’s needs.</p><p>Technically you could use one of the available ready-made design systems for Figma, but I’d argue this is not a very good idea unless you’re trying to create something in a hurry. I believe it’s always best to put in the time to build your project from the ground up. This will allow you to better understand how each component is created and solve any issues that may arise while working with the design system.</p><p>Sometimes it can be hard to create a design system without seeing the bigger picture. It’s a good idea to base your design system around an already finished project.</p><p>The first and most important thing is creating a proper grid for your design system. Depending on what kind of framework you’ll be working with, you could be using different types of grids. The one I personally use most often is the Bootstrap grid. I like to set up my grid to not only help me space around objects horizontally but also vertically. I’m not going to go into why you should be using a grid, as that’s a subject for another article.</p><figure><img alt="Your grid for Macbook Pro sized screen or similar should look something like this." src="https://cdn-images-1.medium.com/max/851/1*ONWGU6ofVJsRR2oYHdEfrw.jpeg" /><figcaption>Your grid for Macbook Pro sized screen or similar should look something like this.</figcaption></figure><p>You should turn thus created grid into a style. Now if you haven’t done that already, it’s also a good idea to go into the Figma hamburger menu &gt; Preferences &gt; Nudge Amount and set the values to 1 and 8. This way your keyboard arrow keys in combination with the shift key will allow you to move the objects around while sticking to the grid you’ve just created.</p><figure><img alt="Figma lets you decide the exact amount of pixels for the shift+arrow combination." src="https://cdn-images-1.medium.com/max/1024/1*IG_S_y447AJx4nixTZ7eYA.jpeg" /><figcaption>Figma lets you decide the exact amount of pixels for the shift+arrow combination.</figcaption></figure><p>The next step is to create a bunch of font styles that we’re going to be using in our project. It’s important to remember to cover all the basics such as several styles for headlines, paragraph texts, hints, captions, and such. Do as many as the kind of projects you’re involved with may necessitate. You might think to yourself: “Hey, why not have the same style for buttons and menus since they use the same font?” Well, you might find yourself in a bit of a pickle if it turns out that you only need to change the font size for your menu elements at a later stage of your project.</p><figure><img alt="Font setup for the simple, reusable design sytem." src="https://cdn-images-1.medium.com/max/1024/1*1rzG9SqSkXjgABD1uFb1VA.jpeg" /><figcaption>This is what your font setup should look like.</figcaption></figure><p>I like to keep all my font styles displayed in a frame, so I know whether they play well together or not. This kind of setup will be necessary if you decide to duplicate your design system instead of using it as a library for your project, but I’ll get back to that later. Generally this amount of styles should be enough for any kind of average-sized website with a decent amount of text in it.</p><p>When it comes to colors I usually define styles for the brand colors, the action color, and some grays. You might want to define styles for important, warning, success, error messages, and such as well. Dealing with a strictly defined palette makes not only the design process but also the hand-off much easier.</p><figure><img alt="Color setup for a simple, reusable design system." src="https://cdn-images-1.medium.com/max/1024/1*RPD-OPF2Bh56bJaJhyIQgA.jpeg" /><figcaption>Color setup for the simple, reusable design system.</figcaption></figure><p>A basic set of often-used icons is also a good idea. I’ve used Google’s Material icons for this example. Even if you‘re tasked with designing your own set you can use these as placeholders in early mockups that are easy to replace at a later time.</p><figure><img alt="Set of icons for the design system." src="https://cdn-images-1.medium.com/max/1024/1*aQ2xUypILlOIVbflAcic0w.jpeg" /><figcaption>Set of icons for the design system.</figcaption></figure><p>Even though there’s a variety of plugins that can automatically generate content for you such as avatars or images, I prefer to create a predefined set of images or avatars as styles, to retain coherence in case I decide to use them as placeholders.</p><p>It’s not very intuitive, but Figma lets you set up images as color styles that you can later use like any normal color style — to fill a given object using a predefined set of characteristics. What’s even more interesting is that objects can have a lot of fill layers within themselves that interact with each other (this also applies to strokes, effects and so on) and so a group of fill layers all within a single object could be defined as an easily modifiable style. Fill layers can also be moved to front or back and copied between objects. This is an awesome feature that not a lot of people know about.</p><figure><img alt="You can turn images into color styles in Figma" src="https://cdn-images-1.medium.com/max/1024/1*02kdkkrMXM65-UVa3vtMyw.jpeg" /><figcaption>The magic of Figma, turn images into color styles.</figcaption></figure><p>You can of course achieve similar effects by setting up images as components, but you can’t use components as fills.</p><p>The last step is to create some shadows for your project. For a small design system I wouldn’t bother with an entire complex elevation system, just a couple of different shadow styles should be enough.</p><figure><img alt="A bunch of shadow styles for the small, reusable design system." src="https://cdn-images-1.medium.com/max/1024/1*yrRixBVrQBpmjNizCu0PgQ.jpeg" /><figcaption>Just a couple of shadow styles. It ain’t much, but it’s honest work.</figcaption></figure><p>Once you have all the styles set up this way it’s time to start putting together some components.</p><p>Before Auto Layout there was a whole different approach to creating buttons. You’d start with defining shape components that would then serve as button backgrounds through using appropriate constraints. You’d use these shapes across all your components so that if you decided to change your corner-radius, this change would affect all your buttons, images, input fields, and so on. While this technique still has its merits and can still be used in some situations, it won’t work with Figma’s Auto Layout feature.</p><p>Auto Layout is an amazing feature, but in the case of buttons it’s not always the best solution. Sometimes you need to size your buttons according to a grid. Some of the projects I’ve worked on necessitated both, standard and Auto Layout buttons. Some of them could do without Auto Layout at all. Not one could do without the standard, non-Auto Layout buttons. When creating a small design system such as this one I’d stick with non-Auto Layout buttons.</p><p>At this point you actually start using your styles. You can use your Button font style, put it in a frame, fill it with the Action Default style, slap the Button Default effect on it and you’ve got yourself a button. Do this a couple more times to create appropriate styles for different styles.</p><figure><img alt="A set of buttons with different states for the simple, reusable design system." src="https://cdn-images-1.medium.com/max/1024/1*JHqdUXrMHOAlv2MdJvC_Mg.jpeg" /><figcaption>You don’t have to go crazy with the buttons. This is a good starter for smaller projects.</figcaption></figure><p>In the case of a simple design system like this one I’d finish up with a set of inputs in different states. Again, you should base their design on the styles you’ve already created.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Wh2Fx2ekRtdL-v0y3BTDlA.jpeg" /></figure><p>At this point you’ve got all the basic ingredients to start working on a new design. Where you go from here should depend on what kind of projects you do most often and what other patterns could be turned into reusable components that often appear in your projects. Often work with e-commerce websites? It’d probably be a good idea to create some product card components, maybe a checkout form.</p><p>Now there are two ways you can go about reusing your design system for new projects. As with most things in life, each has its pros and cons. Go with whatever is best for your design practices and the type of projects you deal with.</p><p>You can do it the way it was intended by Figma. Use the design system you’ve created as a library. This way you get access to the entire design system right away, but any heavy modifications of the components are out of the question obviously. You can only modify the colors and hide their elements. Other than that you’re stuck with what’s in the design system. The same thing goes for all styles. You can add new ones, but can’t modify the originals. It’d actually be a better idea to split the design systems into separate libraries and so you could, for example, use a button library, a gray color library, an elevation library, etc.</p><p>The second approach and the way I do it is to simply duplicate the entire design system. This way there’s nothing stopping you from modifying all your components. The bad thing about duplicating design systems is the fact that it makes you lose all your styles. You basically need to go through all your fonts, colors, fills, and whatever else you might’ve set up and turn them into styles once again. This isn’t so bad however as it only takes a few minutes and still makes you save a lot of time in the long run.</p><p>Technically a design system is a much more complex structure than what we’ve created so far. But while a complete design system is supposed to include all reusable characteristics and patterns of a design, our basic design system’s goal is to help you kick start your designs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a3a01236a7e3" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/simple-reusable-design-system-in-figma-a3a01236a7e3">Simple, reusable design system in Figma</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Exporting from Figma to After Effects]]></title>
            <link>https://uxdesign.cc/exporting-figma-to-after-effects-b422f3e0e0d3?source=rss-69d79a9e269a------2</link>
            <guid isPermaLink="false">https://medium.com/p/b422f3e0e0d3</guid>
            <category><![CDATA[design]]></category>
            <category><![CDATA[prototyping]]></category>
            <category><![CDATA[visual-design]]></category>
            <category><![CDATA[ui]]></category>
            <category><![CDATA[figma]]></category>
            <dc:creator><![CDATA[Konrad F]]></dc:creator>
            <pubDate>Mon, 04 May 2020 17:03:54 GMT</pubDate>
            <atom:updated>2020-06-14T18:46:02.201Z</atom:updated>
            <content:encoded><![CDATA[<h4>Find out how to export your projects from Figma to After Effects the right way.</h4><figure><img alt="Cover image" src="https://cdn-images-1.medium.com/max/1024/1*EPySN7J4OTpp1z1rKCiyyg.jpeg" /></figure><p>Figma is quite capable on its own when it comes to animating interfaces. As of recently, you can also make use of the excellent Smart Animations for an additional layer of polish. It’s one of the things that makes Figma so awesome — it lets you carry the project from early wireframes all the way up to prototypes and handoff. There may come a time however when even the most diehard Figma believers will be required to leave the comfort of their favorite design environment.</p><p>When you need to deliver a smoothly animated presentation of a product or make it clear to your front end devs how to handle animations that are a little more complex than what Smart Animations can handle I find that there’s no better tool than Adobe After Effects. This might be especially true when you’re stuck on the Windows platform.</p><figure><img alt="After Effects timeline" src="https://cdn-images-1.medium.com/max/1024/1*txz-cJhAqRYB4tghLZgkMg.jpeg" /><figcaption>Adobe After Effects interface</figcaption></figure><p>AE could be considered a bit of an overkill for the job as it’s not strictly geared towards animating interfaces. It’s probably the most complex animation tool and UI animation happens to be one of the many things it can do.</p><p>There’s at least one tool out there that lets you easily move your projects from Figma to After Effects. Unfortunately the easiest method is not always the best, and the coherence of the converted project with the original one is inversely proportional to its complexity. That is why my team and I opt for exporting screens manually.</p><p>To do that you need to approach every screen as a separate project and disassemble it into many pieces. The pieces don’t need to correspond with the groups and layers of your original project. What’s important is to think about them in the context of the animation.</p><figure><img alt="This image explains how to export groups of objects" src="https://cdn-images-1.medium.com/max/1024/1*FLD-kOmJg4s3EKLBG2_3fQ.png" /></figure><p>Take the above wireframe as an example. Let’s say we want the light gray background color to fill the screen first and then have the rest of the elements appear in a sequence. First the tabs from left to right, then the underscore, and then the text boxes (A) all as a single group. Sure, this is not something you normally need AE for, but for the sake of the example, we should keep things simple.</p><p>We’re going to focus on the headline, the paragraph, and the link below first (1, 2, 3). Say you want them brought into existence through animation as a single element. That means you need to treat them as a group (A) that’ll end up as a layer in After Effects.</p><p>What you need to do is create a new frame with the same size as the size of the project and put the aforementioned layers in it (make sure you paste while the new frame is selected to retain the elements’ position) or duplicate your project frame and delete everything but the layers you need.</p><p>Of course to put together an animation in After Effects you’re going to need a bunch of other frames in Figma, all containing some parts of your project. In the case of the above example, we need 6 layers: the background, the tabs (all kept in separate frames), the underscore, and the text group we’ve already talked about.</p><figure><img alt="Animation showcasing the end result" src="https://cdn-images-1.medium.com/max/384/1*CMqQ2mOvC1jx_sOyqNtnuA.gif" /><figcaption>The result should look something like this.</figcaption></figure><p>Any kind of complex animation will naturally require a good amount of preplanning. Only when you have at least a rough idea of how you’re going to go about animating your project can you start slicing it into pieces. I’ll explain how to put together a simple interface animation in After Effects in my next article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/76/0*9ZEQJ9FbHX7TQHGx" /><figcaption>The UX Collective donates US$1 for each article published in our platform. This story contributed to <a href="https://medium.com/uxmpretas">UX Para Minas Pretas</a> (UX For Black Women), a Brazilian organization focused on promoting equity of Black women in the tech industry through initiatives of action, empowerment, and knowledge sharing. Silence against systemic racism is not an option. Build the design community you believe in.</figcaption></figure><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=b422f3e0e0d3" width="1" height="1" alt=""><hr><p><a href="https://uxdesign.cc/exporting-figma-to-after-effects-b422f3e0e0d3">Exporting from Figma to After Effects</a> was originally published in <a href="https://uxdesign.cc/">UX Collective</a> on Medium, where people are continuing the conversation by highlighting and responding to this story.</p>]]></content:encoded>
        </item>
    </channel>
</rss>