January 29th 2021

The incremental releases we have done in the new year contain a few small features, and a lot of improvements and fixes!

We have added support for overflow styles on container layers, as well as a border style section (to specify solid/dotted/dashed).

We have also made the default text style that is applied for newly added text layers configurable on the settings page - which has moved into the home tab (under Recently viewed)!

We have also added an option to start from an empty project for users who don't want any sample components.

We have made a lot of UI tweaks and performance improvements to the app. We have added back the R and C hotkeys in the editor to add row/column style container layers.

For our primitives, we have added some missing aria props (to the text field and radio button). We have fixed dividers not showing up in preview mode. We have fixed the select primitive's preview, and added a y-offset style option to it, as well as some typeahead support. We have set the default delay for tooltips a bit shorter, and we have made sure that the first element in menus auto-focuses. The primitives' usage examples have also been updated.

New features

  • Support overflow options on containers
  • Support for border styles
  • Default text style configurable in settings


  • UI tweaks
  • Performance improvements
  • Add option to start from empty project
  • Add some missing aria props (text field, radio button)
  • Fix dividers not showing
  • Fix select preview and add y-offset style, improve typeahead
  • Use shorter delay for tooltips
  • Auto focus first element in menus
  • Fix primitives' usage examples
  • Add R and C hotkeys in editor for adding row/column style containers

December 10th 2020

This week's release contains a ton of new features and improvements, more than any prior week!

We've launched entirely new tutorials and documentation pages, rewritten from the ground up. Learn how every aspect of Visly works, including how you can get started using Visly together with frameworks such as Next.js and Gatsby.

We're also introducing the Visly UI kit, the quickest way to get started with Visly. Within 5 minutes you’ll have a fully customized design system, ready for you to use and extend! While Visly is already the most customizable design system out there, it wasn't the quickest to get started with — now there's no longer a compromise between setup speed and future flexibility.

Rounding off the big new features launching today, we're also introducing new team features! These include a visual code review tool that allows you to review pull requests visually (instead of trying to parse and visualize hundreds of lines of CSS), and the ability to share a web-based version of your Visly library with coworkers and clients.

In addition to these features, we've kept working on the quality and performance of the core application as well, resulting in:

  • A 60% reduced application size;
  • Significantly improved UI and startup performance;
  • Improved navigation between inner components; and
  • Clearer separation between props and variants.

November 24th 2020

This week we are introducing the documentation sidebar! Toggle the this new sidebar from the help button to the right in the tab bar. It's available within the component editor as well as on the home screen. From here you'll be able to browse through Visly's documentation, watch tutorials, and even read up on the latest changes!

As part of this new documentation sidebar we are also introducing the ability to report bugs and request new features directly from the app! The new bug reporting flow will even give you an opt-in option to include the components you are working on so that we can find and fix an issue even more quickly than before. The sidebar also includes a link to our slack community for early Visly users, so make sure to join and say hi if you haven't already!

You'll also notice a few info icons spread across the interface, we've placed these next to features we know may require some further explanation. Click the icon to open the documentation sidebar to the corresponding article or tutorial. If you want to turn off these hints you can do so from the top level navigation of the documentation sidebar.

In addition to the documentation improvements, this update also includes the following bug fixes:

  • Inner components can now be renamed directly from the canvas;
  • Canvas now correctly defaults to 100% zoom for new components;
  • Fixed a bug where selections in list components wasn't working as expected;
  • Improved the API of list components to better handle single selection mode;
  • Fixed a bug which caused certain containers to have overflow:hidden set when not configured; and
  • Fixed an issue where Select components would throw an error in rare cases.

November 16th 2020

This week we looked at our token pickers and how they could be improved to help you design and build components more quickly. We are really happy with the result and excited to share them with you all for further feedback.

  • Color pickers now include many more colors in the same amount of space as before;
  • Text style popovers actually display the font and relative size of the text style;
  • Font picker choices now render in the font they represent; and
  • Fonts and text styles in the token sidebar now render in their respective font and font size.

In addition to these improvements to the way you manage and use tokens in Visly we have also fixed a number of smaller issues reported to us since last week's release, including:

  • Padding is now correctly applied to the container of a menu components built in Visly;
  • Fixed an issue where folders weren't correctly merged when using visly resolve;
  • Fixed an issue when merging added assets from multiple branches using visly resolve;
  • Added utility functions for using Menus and Popovers; and
  • Fixed an issue where empty folders weren't being displayed correctly.

November 11th 2020

This week's release is packed to the brim with bug fixes, other smaller quality improvements, and a huge leap in accessibility support! This release introduces the FormLabel primitive, just select it when creating a new component. By using a FormLabel component built in Visly, you can ensure all of your form controls also built in Visly (checkboxes, switches, inputs, and more!) have the correct accessibility properties. So now you can make sure your application supports everyone!

In addition to these important accessibility changes we've also fixed a lot of smaller bugs and other issues. Over the past week, we've:

  • Ensured that text labels in ListRow components now can't overflow;
  • Adjusted the focus state of inputs to be consistent throughout the app;
  • Fixed an issue where color pickers had duplicate options for "No fill";
  • Fixed an issue that caused Slots to display larger than expected in some cases;
  • Made sure the select component popover does not flip position when it no longer fits the available space;
  • Slightly re-designed the tab bar with additional labels for clarity; and
  • Fixed the naming of inner components in Menu primitive.

November 4th 2020

Today we are introducing Visly accounts! You'll be asked to sign up using GitHub the next time you open Visly. Once an account has been created you can link it to your GitHub organization and the rest of your team can join you. Currently there is not much more to say regarding teams on Visly, however a few weeks from now we will be launching Visly's first premium features. These upcoming features will make collaborating as a team on Visly projects much more enjoyable. More on that soon!

Additionally we also made the following improvements:

  • Fixed an issue where overflow was not functioning correctly;
  • Added a menu primitive for creating context menus as well as popover menus;
  • Added the ability to better configure the pointer arrow on tooltips; and
  • Added support for row-reverse and column-reverse.

October 27th 2020

We're constantly improving Visly to ensure it works for you, whatever project you are working on. Today we are releasing a new version of Visly with a lot of smaller improvements, most of which are directly influenced by the feedback from our beta community (thanks, everyone!).

First of all, we made huge improvements on the performance front. Visly's code generation is now 3x faster, meaning hot-reload is quicker than ever! Additionally, we rewrote the implementation of Select components to make use of virtual scrolling, which has significantly improved the performance for selects (dropdowns) with many items.

Secondly, slots have received a ton of love this week. It's now possible to set the background color of a slot, and more importantly we now enable setting a preview size for a slot. This means you will no longer have slots in your Visly component that have zero width or height. With preview size, you can set the size the slot should be in the editor without affecting the size it will be when used in code. We've also added better visualization to slots in the editor, so it's clear which parts of your component are to be filled in from code.

And finally, we've added the ability to clarify which HTML element should be used to render text layers and containers. This is an important feature for accessibility and SEO, where it's necessary to have semantic HTML. You can now tell Visly to render a text layer as an h2 or a container as a section.

Additionally we also fixed the following issues:

  • Made lists, tooltips, and progress primitives non-interactive;
  • Made overflow a setting on all layers;
  • Enabled clicking the frame background to select the root layer; and
  • Fixed a bug causing components not to load on rare occasions.

We've also updated @visly/core, make sure to bump this to version 1.0.6 in your **package.json**!

October 20th 2020

Half the memory, twice the fun! This past week we've put in a lot of work to make sure Visly works well on your machine, no matter how powerful it is. Through a combination of bug fixes and plain old optimizations, we've drastically lowered the amount of memory Visly uses, as well as improved the general performance of navigating through the app. This should make Visly even more enjoyable to use :)

In addition, like every week, we've made smaller improvements as well. This past week we've:

  • Added focus states in places they were missing;
  • Fixed a bug causing the whole app to close when trying to close a single tab;
  • Fixed an issue with transform scale not being correctly calculated;
  • Fixed a bug which caused the right sidebar not to update when switching layers;
  • Fixed an issue with hot-reload not using the latest changes when doing multiple updates quickly; and
  • Fixed selections for inner components.

October 12th 2020

Today marks by far the largest update to Visly ever with the introduction of Frames and Folders. Frames enable you to see all your component variation and interaction states on the canvas at the same time. This change makes it far easier to get an overview of your component and editing a specific variant or state is as simple as clicking on the layer you want to edit. Folders help you organize your ever growing library of components into smaller folders. Not only is this great for more quickly finding what you are looking for (we also including a new search feature!) but it also enables you to keep components organized in a similar way to how you organize your code.

In addition to these huge improvements, we've also made great progress on smaller features as well as fixed some of the bugs you've reported over the past week. To name a few, we've:

  • Added server side rendering support to useBreakpoint hook;
  • Added the ability to create new tokens from color & spacing pickers;
  • Fixed the issue with redo sometimes not working after an undo operation;
  • Fixed preview mode for Lists;
  • Added the ability to search for components in the home tab;
  • Added the ability to customize the css cursor attribute on components; and
  • Fixed the issue where projects would not save and/or load indefinitely.

September 30th 2020

We're working on some major changes to the core Visly experience that we're super excited to show you soon! In the meantime, we've been hard at work on improving many smaller interactions as you build components. We are especially happy to introduce the updated dimension inputs (built in Visly!). They allow you to easily use raw pixel and percentage values or of course you can also press the token button to use a size token.

Additionally we have also fixed a number of bugs you've reported in the past week. Including but not limited to:

  • Adding an option for creating containers that wrap their contents using flex wrap;
  • Fixing a crash when dragging input into inner components;
  • Fixing the deletion of icons and fonts;
  • Fixing a bug causing inner components not to be able to be expanded;
  • Selecting all text in input when focusing inputs; and
  • Improving the performance of panning and zooming on the canvas.

September 21st 2020

This release brings a much asked for feature - shadow tokens! It is now possible to define a shadow in a reusable way to have consistent elevation throughout all your components. Like any other tokens in Visly, shadow tokens can be accessed in the editor but also directly from code.

Apart from shadow tokens, this release also includes features such as support for HLS colors as well as a number of bug fixes and performance improvements!

August 27th 2020

This has been one of the most productive weeks at Visly HQ - This latest release brings with it Size tokens, responsive design support, new canvas options, and the introduction of @visly/core!

Introducing @visly/core

With this release we have added a required dependency for all applications using Visly, @visly/core. This dependency enables us to include utilities without bloating your generated code. The first usecase for this new functionality is the addition of react-aria, a fantastic library which ensures all your components meet accessibility guidlines. We are slowly transitioning all Visly components to make use of this functionality.

All you need to do is yarn add @visly/core / npm install @visly/core and you will be all set.

Size Tokens

Starting today, Visly has support for Size tokens. Size tokens are a feature which let's you declare a variable for a certain size, for example 10px and use that variable throughout your components. This makes spacing consistent throughout your whole application and also enables quickly changing the spacing used within your app from a single location. Like all other tokens, size tokens are available both from within Visly and for use directly from code.

import { sizes } from 'visly'

function Component() {
    return <div style={{margin: sizes.spacing.smallSpacing}}/>

Responsive design

We have heard loud and clear that you want support for designing responsive components in Visly. We are happy to say that the first version of this support is now ready, and it's super easy to get started with. Just define your various size classes as variants from within the Visly editor and use our new useBreakpoint() hook to pick the correct size variant from code. This will automatically adjust your UI based on the device and browser size running your code. Learn more about designing responsive component in Visly here.

import { Button, useBreakpoint } from './visly'

export default function() {
  const size = useBreakpoint('small', ['medium', 'large'])
  return <Button size={size} />

Canvas background

Up until this point it was sometimes frustrating to design component in Visly as the contrast to the background of the canvas was too low to make out finer detail. This was especially true for application which use a ligher colorscheme. Starting in this release we are adding support for configuring the background color of the canvas, making sure you can see all the details of the component you are building.

We've also fixed a few bugs and limitations.

  • Display errors on components originating from inner components
  • Display errors when text styles are missing a font
  • Update font when uploading new version to Visly
  • Allow configuring overflow, flex, and dimensions on tooltip components
  • Reload project when changing git branch
  • Components and tokens are now sorted alphabetically

August 21st 2020

After weeks of focusing on performance and stability we are back to shipping features you have been asking for! This week we have combed over every part of Visly to ensure the colors and text styles we use pass standards for accessible applications. You'll see a bit more contrast throughout the app and a new Font (Inter!). We've also added support for all new text controls such as uppercasing and underlining text layers.

In addition to these changes, this release also includes some smaller updates such as:

  • Faster performance of undo & redo
  • Fix for selection boxes sometimes being mis-aligned
  • Fix for placeholder value not being correctly set on composite components
  • Fix for tooltips sometimes overlapping the clickable element
  • Allow inner components to have the same name as their parent component
  • Show a notification to confirm changes to tokens
  • Allow undo & redo of tokens outside the editor page
  • Fix crash when attempting to delete a font

August 10th 2020

These past two weeks we have been focused on one thing, and one thing only, performance. We have profiled and optimized every interaction to make it as fast as possible. On average, actions taken in Visly are now 5x faster. Everything from selecting a layer to creating a component. While this may not be very noticable in smaller components, it makes a huge difference in larger components.

Going forward we are shifting focus away from just focusing on performance and stibility (as we think they are in a pretty good place) and instead focusing on shipping many of the small and large features you have been requesting. Including, but not limited to, spacing token, support for text decorations, and letter spacing.

July 20th 2020

As we continue onboarding hundreds of new users to Visly every week, we have been working on resolving any issues and pieces of feedback you have provided us. We've heard you loud and clear, the onboarding flow was buggy and at times confusing. While we are working on revamping it entierly, we have updated it to solve the largest pain points and made sure to squash any known bugs.

Aside from this we have also fixed a long list of bugs you have been reporting. Here are some of the main ones.

  • We improved the performance and accuracy of moving layers
  • Added the ability to specify negative shadow spread
  • Fixed an issue where default values were not applied to new styles
  • Fixed bug where ToggleButtons were't generated the correct code
  • You can now hit return on your keyboard to save an edited token
  • Greatly increased the amount of history we save in undo/redo stack
  • Improved performance of resource loading. Tokens should now load more quickly
  • Align the order of padding/border inputs with what is expected from css
  • Sort component alphabetically in layer picker so components are easier to locate

June 29th 2020

As hundreds of new users are gaining access to Visly each week, we've been focusing all our efforts on fixing bugs and smaller issues you guys have been reporting - you can see the details of what exactly we've fixed below. Thanks to everyone who's sent in feedback so far - please keep it coming!

Our main focus for the next few weeks outside of ramping up invitations is to improve the performance of Visly for larger projects and fix any issues that come up as you start to build UI with Visly.

As I mentioned above, we're onboarding hundreds of new users to Visly every week now - if you'd like like to be one of these early users, you can request access here.

Fixed this week

  • Fixed an issue where dragging a layer could result in an application crash under specific conditions.
  • Fixed an issue that sometimes caused dimensions to include floating point artifacts.
  • Fixed an issue where rotation of a layer could not be un-set once added.
  • Fixed a issue causing the app to crash under certain conditions.
  • Ensured tooltips aren't cut off by the edge of the application window.
  • Fixed an issue that caused inner components to render multiple times in preview.
  • Fixed an issue that prevented deeply nested inner components from generating any code.

June 23rd 2020

You may have noticed that we've been quiet this past month. And that's because our team has been incredibly hard at work to deliver a whole suite of amazing updates to Visly. We've closed over 100 small bugs and pushed some big new features, including a style guide for all your components, Next.js support, and support for sub-components.

We've also ported most of our user-facing UI components to be built in Visly. As a result, there's now less code to maintain and our design team is now able to contribute using pull requests. Starting this month, we'll also be opening up Visly to many more people! If you want to ensure you're able to gain access over the next few weeks, make sure to request access now.

May 27th 2020

Redesigned workflow

Over the past two weeks, we have been working on a redesign of all core workflows in Visly. There are too many details to cover individually in a changelog, but some of the highlights are:

  • A new interface for managing design tokens
  • A new interface for managing component props and variants
  • A redesign of the layers panel
  • A new interface for designing interaction states
  • Adjustments to every single UI element to ensure consistency
  • Color pickers for quickly adjusting any color

Overall the app is much quicker than before and should hopefully be much easier to navigate as well. But what's most exciting is the new features this redesign unlocks - more on those in the coming weeks!

May 11th 2020

Tabbed UI

I'm really excited to show off Visly's largest UI change yet - we've re-engineered the whole application, changing it into a tabbed experience instead of a multi-window one 🤩 This greatly improves the experience of managing many components at once, while also improving the performance of the app. This is the first of a few major UI changes we will be announcing over the next few weeks in our lead up to a more public product launch. Thank you to everyone who's provided us with feedback leading to these changes!


This week, we spent a ton of time looking over the performance of loading projects in Visly. We've been able to drastically improve load times for larger projects. Our own Visly project now loads 20x faster than in previous versions, and this is just the start of more performance improvements coming over the next couple weeks.

Further improved code generation

Building on our work over the past few weeks, we've again looked over the code being generated by Visly, and I'm happy to say that we've taken another leap forward in cleaning it up. By adding a few post-processing steps to our code generation pipeline, we've been able to clean up most of the code that didn't look hand-written. We are now very close to generating code without compromises.

Other fixes and improvements

  • Text layers now truncate with an ellipsis when their content does not fit their container
  • Made code generation an atomic operation to improve integration with hot-reloading
  • Fixed an issue where in some cases composite components would wrongly inherit parent styles
  • Fixed crash that happened when moving a project file while Visly is open
  • Fixed an issue causing Slots to be unable to be renamed

May 5th 2020

Cleaner code

You may recall in a previous update that we reduced the amount of code Visly generates by 80%. Now, we’ve gone back and cleaned up the code we generate further to make it more readable and concise, improving your understanding of the generated code and making your bundle sizes smaller. At this point, the code we generate is very close to handwritten code, but we think we can go even further. In the future, we're aiming to optimize the output to be even smaller than what you may have written by hand. You can read more about other ways we're prioritizing building trust with developers here.

Select & Slider primitives

This week brings two more primitives to Visly. You can now style and build custom sliders and select (dropdown) components directly in Visly. These are super flexible, so whether you want to build a select component with just an icon, some text and an icon, or something entirely of your own creation, it's now possible. These primitives also have built-in support for keyboard accessibility as well as the necessary aria tags, so they can be used by anyone.


One of the main things we're focused on as we approach a public launch is improving the way we onboard users, teaching you the basics of using Visly and showing you how to integrate it into your workflow. This week we've taken a huge step forward in this by adding an interactive tutorial that takes you though all the basic features of Visly. The coolest part is how, since the onboarding flow is built in Visly, you get to do a bit of onboard-ception, learning some Visly basics by editing the onboarding tutorial itself as you experience it 🤯

Other fixes and improvements

  • Fixed issue with renaming slot props
  • Fixed issue with collapsing style sections
  • Added ability to configure opacity of root layers
  • Fixed issue with background colors sometimes not displaying correctly
  • Added the concept of system assets (that come pre-bundled with Visly)

April 27th 2020


With today’s release, you can now add a transform to any component or layer. This includes the ability to scale, rotate, or apply a translation. We’ve found this most useful when adding subtle hover effect on elements. You can see this in action on - if you hover over a blog post, you'll see the component scales up ever so slightly. Transforms work great together with the transition support we added two weeks ago, allowing you to animate changes in transform across states and variants.

Radio groups

Last week, we added support for building segmented controls in Visly. While radio groups / buttons could be built using a segmented control, we received feedback that it would be great to have an easier way to build this common control. We heard you loud and clear (TODO: insert pun about radios), and from this week, we're happy to say that Visly has built in support for building and styling radio groups.

Dialogs & Popovers

You may notice that Visly makes heavy use of both popovers and dialogs to present controls. These UI patterns are great for giving you quick access to tools without cluttering the UI. However, Visly didn’t support building these, so we had to implement them the old fashioned way, with a bunch of css and boilerplate code. No more! Visly now supports styling dialogs and popovers, as well as the building of entirely custom modal UIs.

Other fixes and improvements

  • Added default styling for borders, shadows, and backgrounds;
  • Added ability to style dividers in segmented controls;
  • Removed unnecessary “Sub component” layer within segmented control;
  • Fixed issue where deleting layers would cause application to hang;
  • Fixed issue where dragging assets into Visly would not update existing assets;
  • Fixed issue causing progress bars not to be able to be embedded within other components; and
  • Fixed issue causing padding to be reset when toggling between individual and all padding options.

April 20th 2020

Segmented controls

The past few weeks we’ve been quietly working on new features to the core of Visly’s architecture to allow for you all to build much more complex components with built-in logic. The first template to take advantage of this new infrastructure is SegmentedControl. This control is highly customizable and allows you to build types of UIs that require the user to pick one of many options. Upcoming releases will include more templates making use of this infrastructure, like Dropdown and Selecttemplates.

Container spacing

We recently published a blog post detailing what we have called Layout-isolated components. Layout isolation is all about making components reusable. This post explains some of the reasons why Visly doesn’t use margins. Spacer, which replaces margins in Visly, works really well 😊 However, we recognize that it can sometimes be annoying to repeat the same spacer between every child. To solve this, we have introduced spacing as a property you can style on any container. You can find it next to the new dropdown for picking a container’s flex direction.

Overflow styling

Initially, all components by default included an overflow: hidden style. This is generally a good default and for a long time we didn’t run into any problems with it. However, as we introduced overlay containers last week, we started getting feedback that developers couldn’t build badges and other UI that was partly overlapping or partly outside the container. We still think overflow: hidden is a good default, but we now allow you to enable overflow on any container with the click of a checkbox.

Other fixes and improvements

  • Fixed issue causing color alpha in variants & interaction states to be unable to override default values.
  • Fixed crash that occurred when quickly deleting two layers.
  • Fixed visual glitch where text inputs overflowed style sidebar.
  • Fixed issue that caused high CPU usage when multiple windows were open.
  • Fixed issue that caused the original component to be changed when editing a duplicated component.
  • Fixed issue causing fonts not to render correctly inside the project picker.
  • Fixed issue causing interaction states not to be visible when a layer wasn’t selected.
  • Added the ability to set an alt text value on image layers.
  • Added the ability to set layout properties on slots.
  • Updated icons for primitives and templates.
  • Added layout styles to components built from the button template to allow for more customisation.
  • Added the ability to insert child layers inside Input components, enabling more customisation.

April 14th 2020


People have been asking us for this one for a while now! We finally have support for transitions in Visly. With transitions, you can control how layers animate between both interaction states and as variants. It's simple enough to quickly create a button that animates background color and powerful enough to animate between a collapsed and expanded list item.

Additional templates

Templates are a feature of Visly that allow you to build components with complex interactions, such as toggle buttons, tooltips, and checkboxes. We've added a quite a number of new templates this week, greatly increasing the amount of UI which can be built with Visly. Please continue to let us know what more you find missing. This week we have added AvatarToggleButtonTooltip, and ProgressBar. We have also made great improvements to existing templates such as InputCheckbox, and Switch. More to come next week!

Improved code generation

This version of Visly brings with it huge improvements to code generation. We have been able to reduce the amount of css and javascript we generate by over 80% in some cases. While we still have improvements to make in this area, we are now much closer to generating the same amount of code you would have written by hand.

Other fixes and improvements

  • Ability to set alt text on images
  • Fixed bug causing interaction states to be unable to override the alpha value of a color
  • Fixed bug causing spacers to display in the wrong size when using variants
  • Added ability to espace out of any edit modes
  • Fixed bug where min-height wasn't working in some cases
  • Implemented a new UI for updating to new version of the app, should fix any auto-update issues
  • Fixed bug causing some styles on the root layer to be unable to be set from code

April 6th 2020

Variant props

Since its initial beta launch Visly has supported the notion of variants, a way to make alternative versions of a component. Today we are expanding this concept to what we call variant props. With variant props you can define a component prop (either enum or boolean) which applies a set of styles to your component. For example you could make a large variant of a button, in addition to a secondary variant. These can this be mixed to create a large secondary button.

import { MyButton } from 'visly'

export default () => (
	<MyButton large type="secondary" text="Open Visly" />


We’ve added the ability for Visly components to define slots. A slot is a placeholder for a child component, or collection of children components. Using slots you are able to design containers in Visly and then pass it child components which you have defined in code.

import { MyComponent } from 'visly'
import { Button } from '../../buttons'

export default () => (
	// Slot named "rightButton". Acccepts any component
	<MyComponent rightButton={<Button/>}>
		{ /* Slot named "children". Works just like you expect! */ }
		<span>Hello Slots!</span>

A slot is just another layer, add it like you would a text, image, or container.

Other fixes and improvements

  • Fixed issue where inputs weren’t being focused correctly
  • Fixed issue where styles passed from code weren’t correctly applied
  • Significantly cleaned up generated code to improve debuggability and reduce bundle size
  • Fix issue where props weren’t removed if a layer was deleted
  • Re-designed the styles panel, collapsing unused styles and making it clearing what styles are being overrides in interaction states
  • Added the ability to resize auto-sized components in preview mode
  • Added the ability to add shadows to layers
  • Added overlay layer which enables building z-axis stacked UIs. If you have been missing position: absolute, this is for you.