Post pobrano z: A congested creative road / Un éléphant ça trompe énormément?
 |
 |
| THE ORIGINAL? Land Rover Mexico “Rush Hour” – 2004 Agency : Ogilvy & Mather (Mexico) |
LESS ORIGINAL Land Rover Israel “Heavy Traffic” – 2017 Agency : M&C Saatchi Tel Aviv (Israel) |
Post pobrano z: Sono Motors Introduces The SION Solar Powered Car
The fantasy of having the capacity to drive to work in a solar-powered car is at last turning into a reality. Sono Motors simply uncovered the SION solar-powered electric car gives you the ability to travel up to 18 miles utilizing only energy from the sun. Best of all, the SION isn’t only for the whealthy, since it just costs 16,000 Euros (around $18,600) in addition to the cost of the battery, and it is pressed with unbelievable components like built-in moss filtration, bi-directional charging and integrated solar panels.
Sono Motors Sion Solar Powered Car
A year ago, Sono Motors, a German startup raised over $200,000 create the SION. Utilizing 300 photovoltaic panels, the SION can store enough energy from the sun to give you the ability to travel up to 18 miles, however in the event that you have to travel further, the SION can likewise be energized utilizing a standard outlet, similar to a regular electric auto. Depending on the amount you want to spend, you can rent the battery month to month, or buy outright.
Post pobrano z: Solar Powered Lights For The Yard
When you are lighting your patio the exact opposite thing you need to do is to be stumbling over electrical lines and attempting to put lights close to an outlet to connect them to. Assuming, notwithstanding, you ran with solar lights you wouldn’t have this issue.
Solar lights take their power from the sun, store it in inside batteries and afterward sparkle splendidly all through the dull night. With such a large number of choices, you can have solar lights for security and to decorate your home, all in the meantime and all with bring down power costs while being ecologically inviting. It’s a win.
On the off chance that you have ventures in the yard you might need to utilize lights that will enlighten those means when its dull. This will wipe out searching for the means and lessen mischances. They are pretty accents to your means as well and obviously arrive in an assortment of shapes and hues.
Similarly for a pathway. Enlightening it during the evening removes the mystery from the condition and takes into consideration a beautiful sparkle other than. Way lights can be low to the ground or can be on sticks to make a lovely emphasize to the sides of the way itself. They too arrive in an assortment of shapes and hues to be the ideal expansion to your arranging.
Did you realize that the banner code proposes that you light your banner around evening time? Never fear, there is a solar light only for that reason and now the banner will never look better against the dull sky.
You invest a great deal of energy and cash on your finishing so why not indicate it off around evening time too? There are a wide range of solar spotlights available that will consequently sparkle on your ideal arranging or delightful tree around evening time. You can likewise actualize arranging lights into the finishing itself for complements consistently, day or night.
Decks look so happy and summery when they have lights on them. Presently you can get solar string lights to give your deck that awesome light and comfortable feel, and they likewise come in all the prominent shapes and hues.
Post pobrano z: A Personal Journey to Fix a Grunt File Permissions issue
I was working on a personal project this past week and got a weird error when I tried to compile my Sass files. Unfortunately, I did not screenshot the exact error, but was something along the lines of this:
Failed to write to location cssmin: style.css EACCES
That EACCES code threw me for a loop but I was able to deduce that it was a file permissions issue, based on the error description saying it was unable to write the file and from some quick StackOverflow searching.
I couldn’t find a lot of answers for how to fix this, so I made an attempt to fix it myself. Many of the forum threads I found suggested it could a permissions issue with Node, so I went through the painful exercise of reinstalling it and only made things worse because then Terminal could not even find the npm or grunt tasks.
I finally had to reach out to a buddy (thanks, Neal!) to sort things out. I thought I’d chronicle the process he took me through in case it helps other people down the road.
I’ll preface all this by saying I am working on a Mac. That said, I doubt that everything covered here will be universally applicable for all platforms.
Before I talked to Neal, I went ahead and reinstalled Node via the installer package on nodejs.org.
I was told that my permissions issue will likely come up again on future projects until I take the step to re-install Node yet again using a package manager. Some people use Homebrew, though I’ve seen forums caution against it for various reasons. Node Version Manager appears to be a solid option because it’s designed specifically for managing multiple Node versions on the same machine, which makes it easy for future installations and version switching on projects.
With Node installed, I expected I could point Terminal to my project:
cd /path/to/my/project/folder…then install the Node modules I put in the project’s package.json file:
npm installInstead, I got this:
npm: command not foundCrap. Didn’t I just reinstall Node?
Turns out Terminal (or more correctly, my system in general) was making an assumption about where Node was installed and needed to be told where to look.
I resolved this by opening the system’s .bash_profile file and adding the path there. You can get all geeky and open the file up with Terminal using something like:
touch .bash_profile
open .bask_profileOr do what I did and simply open it with your code editor. It’s an invisible file, but most code editors show those in the folder panel. The file should be located in your user directory, which is something like Macintosh HD > Users > Your User Folder.
This is what I added to ensure Node was being referenced in the correct location:
export PATH="$HOME/.npm-packages/bin:$HOME/.node/bin:$PATH"That’s basically telling the system to go look in the .npm-packages/bin/ directory for Node commands. In fact, If I browse into that folder, I do indeed see my NPM and Grunt commands, both of which Terminal previously could not locate.
With that little snippet in hand and saved to .bash_profile, I was stoked when I tried to install my Node modules again:
cd /path/to/my/project/folder
npm install…and saw everything load up as expected!
My commands were up and running again, but I was still getting the same EACCES error that I started with at the beginning of this post.
The issue was that the project folders were originally created as the Root user, probably when I was in Terminal using sudo for something else. As a result, running my Grunt tasks with my user account was not enough to give Grunt permission to write files to those folders.
I changed directory to the folder where Grunt was trying to write my style.css file, then checked the permissions of that folder:
cd /path/of/the/parent/directory
ls -alThat displays the permissions for all of the files and folders in that directory. It showed me that the permissions for the folder were indeed not set for my user account to write files to the folder. I changed directory to that specific folder and used the following command to make myself the owner (replacing username with my username, of course):
sudo chown -R username:staffI went to run my Grunt tasks again and, voila, everything ran, compiled and saved as I hoped.
I know the issues I faced here may either be unique to me or of my own making, but I hope this helps someone else. As a web designer, the command line can be daunting or even a little scary to me, even though I feel I’m expected to be familiar with tools that rely on it.
It’s great that we have community-driven sites like StackOverflow when we need them. At the same time, there is is often no substitute for reaching out for personal help.
A Personal Journey to Fix a Grunt File Permissions issue is a post from CSS-Tricks
Post pobrano z: Designing Between Ranges
CSS is written slowly, line by line, and with each passing moment, we limit the space of what’s possible for our design system. Take this example:
body {
font-family: 'Proxima-Nova', sans-serif;
color: #333;
}With just a couple of lines of CSS we’ve set the defaults for our entire codebase. Most elements (like paragraphs, lists and plain ol’ divs) will inherit these instructions. But what we rarely think about when we write CSS is that from here on out we’ll have to continuously override these rules if we want another typeface or color. And it’s those overrides that cause a lot of issues in terms of maintenance and scalability. And it’s those issues that cost us heartbreak, time and money.
In the example above that’s probably not an issue but I think in general we don’t recognize the true strength and dangers of the cascade and what it means to our design systems; most folks think that the cascade is designed to let us overwrite previous instructions but I would warn against that. Every time we override a style that is inherited we are making our codebase vastly more complex. How many hours have you spent inspecting an element and scrolled through each rule in order to understand why an element looks the way it does or how the long chain of inheritance has messed up your styles completely?
I think the reason for this is because we often don’t set the proper default styles up for our elements. And when we want to change the style of an element, instead of taking the time to question and refactor those default styles, we simply override them – making matters worse.
So I’ve been thinking a lot about how we ought to make a codebase that incentivizes us all to write better code and how to design our CSS so that it doesn’t encourage other people to make hacky classes to override things.
One of my favorite posts on this subject was written earlier this month by Brandon Smith where he describes the ways in which CSS can become so complicated (emphasis mine):
…never be more explicit than you need to be. Web pages are responsive by default. Writing good CSS means leveraging that fact instead of overriding it. Use percentages or viewport units instead of a media query if possible. Use min-width instead of width where you can. Think in terms of rules, in terms of what you really mean to say, instead of just adding properties until things look right. Try to get a feel for how the browser resolves layout and sizing, and make your changes and additions on top of that judiciously. Work with CSS, instead of against it.
One of Brandon’s suggestions is to avoid using the width property altogether and to stick to max-width or min-width instead. Throughout that post he reminds us that whatever we’re building should sit between ranges, between one of two extremes. So here’s an example of a class with a bad default style:
.button {
width: 300px;
}Is that button likely to be that width always, everywhere? On mobile? In every media query? In every state? I highly doubt it and in fact, I believe that this class is just the sort that’s begging to be overwritten with yet another class:
.button-thats-just-a-bit-bigger {
width: 310px;
}That’s a silly example but I’ve seen code like this in a lot of teams – and it’s not because the person was writing bad code but because the system encouraged them to write bad code. Everyone is on a deadline for shipping a product and most folks don’t have the time or the inclination to dive into a large codebase and refactor those core default styles I mentioned. It’s easier to just keep writing CSS because it solves all of their problems immediately.
Along these lines, Jeremy Keith wrote about this issue just the other day:
Unlike a programming language that requires knowledge of loops, variables, and other concepts, CSS is pretty easy to pick up. Maybe it’s because of this that it has gained the reputation of being simple. It is simple in the sense of “not complex”, but that doesn’t mean it’s easy. Mistaking “simple” for “easy” will only lead to heartache.
I think that’s what’s happened with some programmers coming to CSS for the first time. They’ve heard it’s simple, so they assume it’s easy. But then when they try to use it, it doesn’t work. It must be the fault of the language because they know that they are smart, and this is supposed to be easy. So they blame the language. They say it’s broken. And so they try to “fix” it by making it conform to a more programmatic way of thinking.
I can’t help but think that they would be less frustrated if they would accept that CSS is not easy. Simple, yes, but not easy.
The reason why CSS is simple is because of the cascade, but it’s not as easy as we might first think because of the cascade, too. It’s those default styles that filter down into everything that is the biggest strength and greatest weakness of the language. And I don’t think JavaScript-based solutions will help with that as much as everyone argues to the contrary.
So what’s the solution? I think that by designing in a range, thinking between states and looking at each and every line of CSS as a suggestion instead of an absolute, unbreakable law is the first step forward. What’s the step after that? Container queries. Container queries. Container queries.
Designing Between Ranges is a post from CSS-Tricks
Post pobrano z: What is Timeless Web Design?
Let’s say you took on a client, and they wanted something very specific from you. They wanted a website that without any changes at all, would still look good in 10 years.
Turns out, when you pose this question to a bunch of web designers and developers, the responses are hugely variant!
There are certain folks who see this as an intreguing challenge and would relish the opportunity.
Accept.
With glee.
— Jeremy Keith (@adactio) July 27, 2017
Accept the challenge 👌
— Dick (@michaeldick) July 27, 2017
Totally deliver 👍
— Kevin Nagurski (@knagurski) July 27, 2017
This is mostly where my own mind went:
focus on minimalist design and great typography.
— Zach Leatherman (@zachleat) July 27, 2017
I would avoid extremes: no extremely vivid colors; a classic font set; clean but not overly minimal; moderate border radiuses
— keith•j•grant (@keithjgrant) July 27, 2017
Focus on the typography.
— Daniel Sellers (@daniel_sellers) July 27, 2017
Keep it clean and minimal with excellent typography.
— ⌘ Sean Bunton (@seanbunton) July 27, 2017
Plus of course some nods to Motherfucking website and Better Motherfucking Website.
An awful lot of folks would straight up just say no. Half?
Decline.
— Cennydd (@Cennydd) July 27, 2017
To be fair, we didn’t exactly set the stage with a lot of detail here. I bet some folks imagined these clients as dummies that don’t know what they are asking.
Decline the business, because that’s not a reasonable expectation.
— Len Damico (@lendamico) July 27, 2017
Refuse.
— Jez McKean (@jezmck) July 27, 2017
I wonder if the client presented themselves well, clearly knew what they were asking, and were happy to pay for it, if many of these designers would have responded differently.
Laugh
— Woman Code Warrior (@amberweinberg) July 28, 2017
Still, curious that so many designers didn’t see any the challenge here, just the absurdity.
I’m partially in this group! What things can and should we reach for in this project, and what should we avoid?
A) system fonts
B) semantic HTML
C) let the browser's shifting sands on how to render the page update the site for you
D) git drnk— Sean T. McBeth (@Sean_McBeth) July 28, 2017
mobile-first, svg graphics, time spent on ux analysis (card sort analysis etc), decoupled modular micro-service front+back end
— Adam Mackintosh (@agm1984) July 27, 2017
Honestly an SPA, no external dependents, and build an archive and entry mechanism to handle content. Wildcard redirect and buy 10 yr hosting
— Jeff (@etisdew) July 28, 2017
If you're looking for an actual answer besides no, maybe html only, inline styles, nothing dynamic, no external calls.
— David v2.9.5 (@davidlaietta) July 28, 2017
„No external calls” seems particularly smart here.
Based on experience and observation in my time in the industry, I’d say it’s somewhere around 75% of websites are completely gone after 10 years, let alone particular URL’s on those websites being exactly the same (reliable external resources).
Simple, driven by content
— Eric Shuff (@ericshuff) July 27, 2017
Focus on making it easy to publish and manage great content. Because great content can easily outlive 10 years.
— Deepti Boddapati (@DeeptiBoddapati) July 27, 2017
Very basic, content focus without all the pretty things.
— Bethany (@fleshskeleton) July 27, 2017
Minimal. Large text elements with a few images mixed in with the content and little color.
— Veronica Domeier (@hellodomeier) July 27, 2017
Adopt the Craigslist design philosophy.
— Chris Cashdollar (@ccashdollar) July 27, 2017
Borrow from @daringfireball
— Joe Casabona (@jcasabona) July 27, 2017
Hand them the Google homepage.
— Darth Seh (@seh) July 27, 2017
https://t.co/wu3bjk5zoA that would work I guess
— Pascal (@murindwaz) July 27, 2017
Plus things like Wikipedia and Space Jam. Also see Brutalist Websites.
Our very own Robin Rendle had an interesting take. Due to population growth, growing networks, and mobile device ubiquity, they site may not want to be in English, especially if it has a global audience. Or at least, be in multiple major world languages.
Leave it to Sarah to come in for the side tackle:
shape the culture that uses the app/site to hate change
— Overactive Algorithm (@sarah_edo) July 28, 2017
And Christopher to give us some options to keep them on their toes:
A) say, “Is this one of those tricky Google job interview questions?”
B) say, “GeoCities lasted 10,000 years, so this will be easy.”
C) 👀— Christopher Schmitt (@teleject) July 28, 2017
Why do any design at all?
text file on the server root
— Eric Bailey (@ericwbailey) July 27, 2017
Although I might argue in that case, you might as well make it an `.html` file instead of `.txt` so you can at least hyperlink things.
Clearly „it depends” on what this website is supposed to accomplish.
I can tell you what I picture though when I think about it.
I picture a business card style website. I picture black-and-white. I picture a clean and simple logo.
I picture really (really) good typography. Typography is way older than the web and will be around long after. Pick typefaces that have already stood the test of time.
I picture some, but minimal copy. Even words go stale.
I picture the bare minimum call to action. Probably just a displayed email address. I’d bet on email over phones.
Technically, I think you can count on HTML, CSS, and JavaScript. I don’t think anything you can do now with those languages will be deprecated in 10 years.
Layout-wise, I’d look at doing as much as you can with viewport units. Screens will absolutely change in size and density in 10 years. Anything you can make SVG, make SVG. That will reduce worry about new screens. Responsive design is an obvious choice.
Anything that even passably smells like a trend, avoid.
Inputs will also definitely change. We’re already starting to assume a touch screen. Presumably, you won’t have to do anything overly interactive, but if you do, I wouldn’t bet on a keyboard and mouse.
I’d also spend time on the hosting aspects. Register the domain name for the full 10 years. See if you can pre-buy hosting that long. Pick a company you’re reasonably sure will last that long. Use a credit card that you’re reasonable sure will last that long. Make sure anything that needs to renew renews automatically, like SSL certificates.
More thoughts, as always, welcome in the comments.
What is Timeless Web Design? is a post from CSS-Tricks
Post pobrano z: The Critical Request
Serving a website seems pretty simple: Send some HTML, the browser figures out what resources to load next. Then we wait patiently for the page to be ready.
Little may you know, a lot is going on under the hood.
Have you ever wondered how browser figures out which assets should be requested and in what order?
Today we’re going to take a look at how we can use resource priorities to improve the speed of delivery.
Most browsers parse HTML using a streaming parser—assets are discovered within the markup before it has been fully delivered. As assets are found, they’re added to a network queue along with a predetermined priority.
In Chrome today, there are a number of asset prioritization levels: Very Low, Low, Medium, High and Very high. Peeking into Chrome DevTools source shows that these are aliased to slightly different labels: Lowest, Low, Medium, High and Highest.
To see how your site is prioritizing requests, you can enable a priority column in the Chrome DevTools network request table.
If you’re using Safari Technology preview, the (new!) Priority column can be shown in exactly the same way.
You’ll also find the priority for a given request in the Performance tab.
Each resource type (CSS, JavaScript, fonts, etc.) has their own set of rules that dictate how they’ll be prioritized. What follows is a non-exhaustive list of network priority plans:
HTML— Highest priority.
Styles—Highest priority. Stylesheets that are referenced using an @import directive will also be prioritized Highest, but they’ll be queued after blocking scripts.
Images are the only assets that can vary priority based on viewport heuristics. All images start with a priority of Low but will be upgraded to Medium priority when to be rendered within the visible viewport. Images outside the viewport (also known as „below the fold”) will remain at Low priority.
During the process of researching this article, I discovered (with the help of Paul Irish) that Chrome DevTools are currently misreporting images that have been upgraded to Medium as Low priority. Paul wrote up a bug report, which you can track here.
If you’re interested in reading the Chrome source that handles the image priority upgrade, start with UpdateAllImageResourcePriorities and ComputeResourcePriority.
Ajax/XHR/fetch()—High priority.
Scripts follow a complex loading prioritization scheme. (Jake Archibald wrote about this in detail during 2013. If you want to know the science behind it, I suggest you grab a cuppa and dive in). The TL;DR version is:
<script src="name.js"></script> will be prioritized as High if they appear in the markup before an image.<script src="name.js"></script> will be prioritized as Medium if they’re appear in the markup after an image.async or defer attributes will be prioritized as Low.type="module" will be prioritized as Low.Fonts are a bit of a strange beast; they’re hugely important resources (who else loves the „’I see it!”, „Now it’s gone”, „Whoa, a new font!” game?), so it makes sense that fonts are downloaded at the Highest priority.
Unfortunately, most @font-face rules are found within an external stylesheet (loaded using something like: <link rel="stylesheet" href="file.css">). This means that web fonts are usually delayed until after the stylesheet has downloaded.
Even if your CSS file references a @font-face font, it will not be requested until it is used on a selector and that selector matches an element on the page. If you’ve built a single page app that doesn’t render any text until it renders, you’re delaying the fonts even further.
Most websites effectively ask the browser to load everything for the page to be fully rendered, there is no concrete concept of „above the fold”.
Back in the day, browsers wouldn’t make more than 6 simultaneous requests per domain — people hacked around this by using assets-1.domain.tld, assets-2.domain.tld hosts to increase the number of asynchronous downloads but failed to recognize that there would be a DNS hit and TCP connection for each new domain and asset.
While this approach had some merits, many of us didn’t understand the full impacts and certainly didn’t have good quality browser developer tools to confirm these experiments.
Thankfully today, we have great tools at our disposal. Using CNN as an example, let’s identify assets that are absolutely required for the viewport to be visually ready (also known as useful to a someone trying to read it).
There’s really only 5 things that are necessary to display this screen (and not all of them need to be loaded before the site is usable):
background-image placed by CSS. This could probably be an inline SVG).These assets (note the lack of JavaScript) are essential to the visuals that make up the main viewport of the page. These assets are the ones that should be loaded first.
Diving into the performance panel in Chrome shows us that around 50 requests are made before the fonts and leading image are requested.
There’s a clear mismatch between the requests that are required for viewing and the requests that are being made.
Now that we’ve defined what critical requests are, we can start to prioritize them using a few simple, powerful tweaks.
Preload (<link rel="preload" href="font.woff" />) instructs the browser to add font.woff to the browser’s download queue at a „High” priority.
Note: as="font" is the reason why font.woff would be downloaded as High priority — It’s a font, so it follows the priority plan discussed earlier in the „How does Chrome prioritise resources?” section.
Essentially, you’re telling the browser: You might not know it yet, but we’re going to need this.
This is perfect for those critical requests that we identified earlier. Web fonts can nearly always be categorized as absolutely critical, but there are some fundamental issues with how fonts are discovered and loaded:
@font-face rules are discovered.In most cases, fonts are delayed by a number of seconds, just because we’re not instructing the browser to download them in a timely fashion.
On a mobile device with a slow CPU, laggy connectivity, and without a properly-constructed fallback this can be an absolute deal breaker.
I ran two tests against calibreapp.com. On the first run, I’d changed nothing about the site at all. On the second, I added these two tags:
<link rel="preload" as="font" href="" type="font/woff2" crossorigin />
<link rel="preload" as="font" href="" type="font/woff2" crossorigin />Below, you’ll see a visual comparison of the rendering of these two tests. The results are quite staggering:
The page rendered 3.5 seconds faster when the fonts were preloaded.
<link rel="preload"> also accepts a media="" attribute, which will selectively prioritize resources based on @media query rules:
<link rel="preload" href="article-lead-sm.jpg" as="image" type="image/jpeg" media="only screen and (max-width: 48rem)">Here, we’re able to preload a particular image for small screen devices. Perfect for that „main hero image”.
As demonstrated above, a simple audit and a couple of tags later and we’ve vastly improved the delivery & render phase. Super.
69% of sites use web fonts, and unfortunately, they’re providing a sub-par experience in most cases. They appear, then disappear, then appear again, change weights and jolt the page around during the render sequence.
Frankly, this sucks on almost every level.
As you’ve seen above, controlling the request order and priority of fonts has a massive effect on render speed. It’s clear that we should be looking to prioritize web font requests in most cases.
We can make further improvements using the CSS font-display property. allows us to control how fonts display during the process of web fonts being requested and loaded.
There are 4 options at your disposal, but I’d suggest using font-display: swap;, which will show the fallback font until the web font has loaded—at which point it’ll be replaced.
Given a font stack like this:
body {
font-family: Calibre, Helvetica, Arial;
}The browser will display Helvetica (or Arial, if you don’t have Helvetica) until the Calibre font has loaded. Right now, Chrome and Opera are the only browsers that support font-display, but it’s a step forward, and there’s no reason to not use it starting today.
As you’re well aware, websites are never „complete”. There are always improvements to be made and it can feel overwhelming, quickly.
Calibre is an automated tool for auditing performance, accessibility and web best practices, it’ll help you stay on top of things.
As you’ve seen above, there are a few metrics that are key to understanding user performance.
You can set budgets against all these key user experience metrics. When those budgets are exceeded (or met) your team will be notified by Slack, email or wherever you like.
Calibre displays network request priority, so you can be sure of the requests being made. Tweak priorities and improve performance.
I hope that you’ve learned some valuable skills to audit requests and their priorities, as well as sparked a few ideas to experiment with to make meaningful performance improvements.
<link https://example.com/other/styles.css rel=preload as=style> nopush HTTP headers to tell the browser which resources to preload before the HTML has been fully delivered.font-display: swap; with web fonts where possible.The Critical Request is a post from CSS-Tricks
Post pobrano z: How to Create a Subtle Summer Sunset Textured Illustration in Adobe Illustrator
In today’s tutorial, we’re going to explore the process of creating a
nice little summer illustration, using some of the most geometric shapes and
tools that Illustrator has to offer.
Before we start, don’t forget that you can
always add new features to the final result by heading over to GraphicRiver,
where you’ll find a great selection of summer-themed vector items.
That being said, let’s
jump straight into it!
Since I’m hoping you already have
Illustrator up and running in the background, bring it up and let’s set up a New Document (File > New or Control-N)
for our project using the following settings:
And from the Advanced tab:
Even though today we’re not working on
icons, we’ll still want to create the illustration using a pixel-perfect
workflow, by setting up a nice little Grid so that we can have full control
over our shapes.
Go to the Edit > Preferences > Guides & Grid submenu, and adjust
the following settings:
Quick
tip: you can learn more about grids by reading this
in-depth piece on How Illustrator’s Grid System Works.
Once we’ve set up our custom grid, all we
need to do in order to make sure our shapes look crisp is enable the Snap to Grid option found under the View menu (that’s if you’re using an
older version of Illustrator).
Now, if you’re new to
the whole “pixel-perfect workflow”, I strongly recommend you go through my How
to Create Pixel-Perfect Artwork tutorial, which will help you widen your
technical skills in no time.
Once we’ve finished setting up our project
file, it would be a good idea to structure our document using several layers, since this way we can maintain a steady workflow by focusing on one
section of the illustration at a time.
So bring up the Layers panel, and create a total of six
layers, which we will rename as follows:
Quick tip: I’ve colored all of my layers using the same
green value, since it’s the easiest one to view when used to highlight your
selected shapes (whether closed or open paths).
We’re going to kick off the
project by creating the sunset background, so make sure you’re on the right
layer (that would be the first one), and then lock all the other layers so that
we can get started.
Create a 480 x 480 px circle,
to which we will apply a subtle linear gradient, using #EFFF56 for the left
color and #EF6B43 for the right one. Set the angle to 90º, center aligning the shape to the larger Artboard.
Start working on the sun’s glow, by creating a smaller 384
x 384 px circle (#ED7743), which we will adjust by lowering its Opacity to 40%, center aligning the resulting shape to the background.
Add the second glow section using an even smaller 288 x 288 px circle (#ED7743) with a 48% Opacity level, which we will center align to the one from the
previous step.
Create the sun using a 192 x 192
px circle, which we will color using #E87243 and then center align to the
previously created shape. Take your time, and once you’re done, select and group
all four shapes using the Control-G
keyboard shortcut, locking the current layer before moving on to the next step.
Assuming you’ve
finished working on the background, make sure you’re on the right layer (that
would be the second one) and let’s start working on the illustration’s next
section.
Create a 512 x 512 px rectangle
with a linear gradient (left color: #6FA0CD; right color: #7DDBCD; angle: 90º), which we will position over the
lower half of the background’s larger circle.
Quick tip: you might notice that we gave the rectangle a
16 px padding to its left, right and
bottom sides in order to foolproof our design, since we’re going to mask it in
the following step.
Mask the shape that we’ve just created, using a copy (Control-C) of the background, which we
will paste onto the current layer (Control-F),
by selecting both it and the copy and then right
clicking > Make Clipping Mask.
Start working on the water’s outer reflection by creating a 240
x 32 px rounded rectangle (#FFFFFF) with a 16 px Corner Radius, followed by a narrower 176 x 32 px one (#FFFFFF), which we will vertically stack at a
distance of 32 px from one another,
positioning them 32 px from
the water’s top edge (since we’re going to be adding two new rectangles over
those empty spaces).
Start filling up the empty spaces created by the shapes from the
previous step, by creating a 192 x 32 px
rectangle (#FFFFFF), which we will position onto the first gap, and a
smaller 128 x 32 px one (#FFFFFF)
which will go onto the second one.
Adjust the rectangles that we’ve just created by cutting out a 32 x 32 px circle (highlighted with
red) from each of its side sections using Pathfinder’s
Minus Front Shape Mode.
Add the final section using a 64 x 48 px rectangle (#FFFFFF), which
we will position below the smaller rounded rectangle as seen in the reference
image. Once you have the shape in place, select and unite all of the
reflection’s composing shapes into a single larger shape using Pathfinder’s Unite Shape Mode.
Adjust the resulting shape by individually
selecting each of its bottom-center corners using the Direct Selection Tool (A), and then setting their Radius to 32 px with the help of the Live
Corners tool. Repeat the same process for the square corners, using a
smaller value (16 px) for their Radius.
Add the little side sections using two 48 x 32 px rounded rectangles (#FFFFFF) with a 16 px Corner Radius, which we will position at a distance of 16 px from the reflection’s first and
second rounded sections.
Since we’ll want the larger reflection and side sections to act as a single larger shape, we’ll have to select them and then use Pathfinder to create a Compound Shape.
Once we’ve created our compound shape, we can apply a nice smooth white
linear gradient, with a 20% Opacity
for the left color stop and 60% for
the right one, making sure to set the Angle
to 90º.
Add the smaller reflection using a copy (Control-C > Control-F) of the larger one, which we will scale
down using the Scale tool (right click > Transform > Scale >
Uniform > 50%).
Position the resulting shape on the upper edge of the larger reflection,
selecting and grouping (Control-G)
all the shapes together before moving on to the next step.
Make sure you’re on the right layer (that would be the third one) and let’s
start adding a few details to the illustration’s center section.
Grab the Pen
Tool (P), and use it to draw the little island using #C4583B as your main Fill color. Take your time, and once
you’re done, move on to the next step.
Give the island some depth by adding a couple
of darker sections using #AA4531 as your Fill
color, making sure to select and group (Control-G) all its composing shapes afterwards.
Create the little cruise ship using a few rectangles (#C4583B), which we will adjust by pushing some of their anchor
points to the inside. Take your time, and once you’re done, make sure to select
and group all of its composing shapes together using the Control-G keyboard shortcut.
Since the right section of the island will most likely go outside of the
background’s surface, we’ll want to mask it using a copy (Control-C) of the larger circle, which we will paste (Control-F) onto the current layer (right click > Make Clipping Mask).
Assuming you’ve finished working on
the previous section, jump on up to the next layer (that would be the fourth
one), where we will quickly create the clouds.
Start working on the first set of clouds by creating an 80 x 16 px rounded rectangle (#FFFFFF)
with an 8 px Corner Radius, which we
will position at a distance of 56 px from
the background’s left edge and 102 px from
its top one.
Create another 80 x 16 px rounded
rectangle (#FFFFFF) with an 8 px Corner
Radius, which we will position underneath, at a distance of 88 px from the background’s left edge and 16 px from the previous cloud
segment.
Create the inner segment using a smaller 32 x 16 px rectangle (#FFFFFF) which we will adjust by cutting out
a 16 x 16 px circle from each of its
side sections using Pathfinder’s Minus Front Shape Mode.
Create smaller side segment using a 32
x 16 px rounded rectangle (#FFFFFF) with an 8 px Corner Radius, which we will position at a distance of 16 px from the wider lower segment.
Once you’re done, select and group all four shapes together using the Control-G keyboard shortcut.
Create the second cloud group using the same process, but this
time take a couple of moments and play a little with the segments’ length
values, positioning the resulting shapes on the right side of the background.
Select both cloud groups and turn them into a larger Compound Shape, applying a white linear
gradient with a 90º over them, using
an 80% Opacity for the first color
stop and 20% for the
second one.
Finish off the current section by adding the plane trails using two 80 x 4 px rectangles (#FFFFFF) with 2 px left corner Radius, which we will vertically stack 12 px from one another, applying a subtle linear gradient (60% Opacity for the left color stop; 10% Opacity for the right color stop)
to them.
Make sure you’re
on the right layer (that would be the fifth one), and then quickly create the
circular highlight.
Create a copy (Control-C) of
the background’s larger circle, which we will paste (Control-F) onto the current layer, and then adjust by first setting
its color to white (#FFFFFF) and then removing a smaller 448 x 448 px circle (highlighted with red) from its center.
Finish off the highlight by setting the
resulting shape’s Opacity
to 30%.
We are now down to
our illustration’s last section, so assuming you’ve locked the previous layer
and positioned yourself onto the next one (that would be the sixth one), let’s
wrap things up!
Paste another copy (Control-F)
of the background’s larger circle onto the current layer, making sure to change
its color to black (#000000).
Select the circle and then apply a Grain
texture over it, by going over to Effect
> Photoshop Effects > Texture > Grain and setting its Intensity to 11, its Contrast to 100, and its Grain Type to Sprinkles.
Adjust the resulting texture by setting its Blending Mode to Soft Light
and its Opacity to 20% from within the Transparency panel.
Finish off the illustration by selecting and masking its texture so
that it will remain constrained to the background’s surface.
There you have it—a short and simple tutorial on how to create
your very own summer illustration. I hope you’ve managed to keep up with each
and every step, and learned something new during the process.
Post pobrano z: How Tuts+ Has Helped People in Their Careers
People use Envato Tuts+ for all kinds of reasons. Sometimes it’s just for fun or to pick up some creative skills as a hobby. But many people also use the site to help them in their careers.
We ran a reader survey earlier this year, and some of the responses were quite inspiring. Here’s a look at how some of your fellow learners have used the site to help them make progress in their careers.
Quite a few of our learners are students who use Envato Tuts+ to help them supplement their formal school or university education with some extra practical skills.
Bartłomiej Szubert was one of those people. He started to learn web development from our courses and eBooks while studying, and after a few months he prepared his CV and applied for a web developer position at a company in his city. And he got the job!
Right now I’m a Mid-Level PHP Programmer / Senior Web Developer in another company, while my colleagues from university often haven’t even found their first job. And that’s all thanks to Envato Tuts+.
For Pouya Rezaei, it was after graduating from university in Economics & Finance that he realised he wanted to work in a different field. So he set out to teach himself everything he needed to know about designing websites.
Two years later I began freelancing, six years on I am creating websites, design work, PHP, HTML, JavaScript … Everything I learnt and all the CMS plugins I used for my clients when I first started, it ALL was with the help of you guys. I’m living my life doing what I LOVE.
Humaira Mahinur only started on the site a few months ago, but has already learned a lot and is moving towards a freelance career.
I am a learner of web design and development, graphic design and other skills … After completing some projects, by the will of Allah, I will start my career with Envato Studio and some freelance marketplace.
And Michelle Silva is a graphic design student about to graduate and now working in a printing job to gain some experience.
This website has definitely helped me improve in areas that I didn’t understand or weren’t covered in class and need to learn quickly to complete a job. Tuts+ guarantees that the ONE course you watch will help you learn what you need.
Sometimes, people are already on the career ladder, but are not satisfied with the opportunities available to them in their current roles.
Jenny Yamada, for example, says:
I’m using it to refresh my memory and apply for jobs I wouldn’t qualify for otherwise. I was able to build out my website in WordPress from taking Adi’s course.
But you don’t always need to move on to move up. Alexander Kozhurkin was already working as a full-time developer, but felt stuck at a junior level. By learning new skills, he was able to start working on more fulfilling projects.
Now I’m working on an enterprise-level business app. I realized that my success depends on my own efforts, and quality education is the key for this. Envato courses let me grow fast, it’s like watching an expert coding over his shoulder.
Envato Tuts+ is also helping people retrain so that they can make the career change they’ve always dreamed of.
Some, like Dave Perlman, are still in the early stages of a career change, but have accumulated skills that are moving them towards a dream job:
I’m closer now than I ever have been to having a career as a web developer and I’ve only put in about a year learning code.
Others are further along. Treighton Mauldin took a big risk several years ago by quitting his job in the construction industry to pursue a career in web development.
I had no experience, and no clue where to start. When I found Tuts+ I was able to start learning rapidly, going through the free courses and tutorials, and within a year I had my first full-time job as a developer. Now I am a back end developer and am helping lead a development team of four people.
Another person who switched careers with the help of Tuts+ is Traci Brinling. After being laid off three years ago, she decided to follow her passion for animation and break into a new career. She used our online courses and tutorials to help her make the change.
I did something right because I am working as an in-house animator and now just trying to build up my freelance client base.
Meanwhile, Neeru Mokha is using the site to help her get back into work after a career break.
It’s really helpful in updating my resume as I took 4 years of break but now I am getting very close to filling my gap. Videos posted are very knowledgeable and very helpful in improving your basic to advanced level skills.
And so is George Millard:
I have got back into software development after a number of years working in a different field. I am using it to get back up to speed and learn the new languages that are now popular.
Many freelancers use Envato Tuts+ to brush up on their skills and land better contracts. When Christian Nazha had a client ask for a Laravel site, he tried various other sites to get the information he needed, but none could help him. Some had bad English, poor sound quality, or even skipped the basics.
Here I found the perfect combination of explanatory and quality videos.
Meanwhile, self-taught web developer Tracey Niblett is using Tuts+ to improve the quality of her work, resulting in big cost savings.
Tuts+ has really helped to fill in the gaps in my knowledge so that my code has become more efficient and reliable. Reliable code means happy customers and less time supporting and more time developing new stuff so the money I have saved in time supporting has more than covered the cost of my subscription.
Lisette Marie McGrath has been struggling to set up an online business while grappling with health issues. The online courses and tutorials have helped her to keep her skills updated while working at her own pace. Now her health is improving and she’s able to devote more time to her business, using the skills she’s acquired.
Envato Tuts+ has kept me going for the last few years, keeping me interested, inspired and focussed on what matters the most to me.
Meanwhile, Martine Kerr says she went from 813 to over 10,000 Instagram followers in just over a year with videos she’s created using skills learned on Tuts+, and now she’s ready to design and film her own courses.
The skills allowed me to save a huge amount of time in filming and basic editing workflow. I’m now confident enough to create my own online courses.
And finally, what better way to enhance your career than just being better at the day-to-day job you do?
Cassie Porcella got her first job as a corporate web developer/designer five years ago, and she used Tuts+ to help her thrive in the new role. When she started, the company website was very basic, and she used our courses and tutorials to learn the skills she needed to overhaul it.
I quickly started using Tuts+ and it helped me take my coding from basic HTML and CSS to full PHP, MySQL and JavaScript/jQuery. After a full redesign of the site design and architecture to align with our business objectives, I started using Tuts+ to refine the site and add user-friendly features.
But as we all know, technology is an ever-changing industry, and a couple of years ago, Cassie updated her knowledge with the help of Kezz Bracey’s explanations of responsive design.
This course helped me to transform our site and its usability and help future-proof the design structure for the multitude of device sizes. Additionally, it really encouraged me to see a female coder getting recognition in a field where us gals are often the minority. Thanks for providing such helpful tutorials that have helped me excel in my job, which benefits my company, our team members and our customers! I look forward to refining my craft and boosting my skills with your help!
How have you used Envato Tuts+ tutorials and courses? Have they helped you in your career? Let us know in the comments below.
If you haven’t tried our full membership yet, why not give it a go? As you can tell from these stories, many people enjoy the kind of career progress that quickly pays for the cost of the subscription. Try our new combined subscription to Envato Tuts+ and Envato Elements. For just $29 a month, you get unlimited video courses and eBooks, plus unlimited downloads from a huge library of professional-quality graphics, photos, web templates, and much more.
Post pobrano z: Adobe Alternatives: Animation Software
Welcome to the final entry in our series exploring the creative software we have at our disposal outside the familiar world of Adobe. In this article we’ll be going over some awesome alternatives to Animate CC, formerly known as Flash.
Animation in Flash has been used heavily in both game dev and in animated shorts and shows, so we’ll be taking a little look at software you can use for both these purposes. Most of these programs have a strong focus on “skeletal animation”.
For that reason, in case you’re just getting into animation and deciding which tools to use, we’ll start with a quick rundown of skeletal animation to help you better assess the features of each application and which is most suited to you and your projects. Let’s go!
The first step in the skeletal animation process is typically using an external
application to create artwork comprised of multiple pieces on different layers. For example, you might create a character with separate limbs, torso and head.
When your art is finished you import it in pieces into your animation software and reassemble it. Some tools provide means to automate this import process, saving you the trouble of individual layer exports and manual reassembly.
Once your art is laid out on the canvas correctly you then create a skeleton for
your character. Skeletons are comprised of “bones”, and bones get attached to each of the
pieces in your character art. This process is typically referred to as “rigging”.
Now when you move a bone the attached images move and rotate along with it, and by manipulating the position and rotation of the bones you can set your character
into various poses. Animations are created by putting your character in various poses at different points on the timeline and allowing the software to “tween”, (automatically create frames in between), those poses.
If that doesn’t fully make sense just yet don’t worry, as you’ll see some videos of this process below.
Some software takes the skeletal animation process a step further with the addition of “meshes”. Normal bones typically only adjust the position and rotation of attached images. Meshes on the other hand add a series of points over the top of each image, and if any of those points are moved the image’s nearby pixels move too. Through manipulating these points, either manually or via attached bones, you can perform sophisticated bending and warping of shapes, allowing for effects like pseudo 3D rotation or cloth moving in the wind.
Many skeletal animation softwares provide something called “runtimes”, which are libraries of code that allow animation to be rendered at run time in certain game engines or other code based environments. Using runtimes has a couple of benefits.
Firstly, you can dramatically reduce the file size your animations take up because rather than needing an image to represent every frame of a prerendered animation all you need is your artwork in its original pieces and the data on your skeleton and its poses over time.
Secondly, you have the ability to change how the animation works at run time. For example, you might switch out the images associated with your skeleton so you can change your character’s appearance or attachments on the fly. It also allows for smooth transitions between one animation and the next, such as gradually coming to a stop from a running state rather than the body suddenly switching its pose.
That covers the fundamentals of skeletal animation, so now you know what to look for let’s jump into looking at our software!
Spine is a skeletal animation application focused on character animation for game development. It’s one of the most popular tools of its kind, and for good reason. It’s packed with features, has a smooth user experience, and includes a comprehensive list of official and third party runtimes that cover 19 game engines & toolkits and 7 programming languages. Among leading game engines provided for are Unity, Unreal Engine, GameMaker, Construct 2 and Phaser.
Spine comes in two flavors: the “Essential” version for $69 and the “Professional” version with more features at $299. However, the inclusions in the “Essential” version are strong and will take you a long way. You’ll be missing out on meshes, free form deformation, clipping, and constraints, but you’ll have everything else.
I find working with Spine to be a very smooth experience and its rigging process is, in my opinion, probably the fastest most efficient among applications of its kind. Once rigged, posing
characters is intuitive and straight forward. And from there you can
activate the auto key function which allows you to just move the playhead to a
particular time, pose your skeleton, and all the appropriate keys will
be added for position, rotation and so on. Alternatively you can set keys manually if you’d rather have finer control.
Spine has a skin system that allows you to create animations with one
set of attached images, then use the same animations again with a
totally different set of images. You can use this to create different
versions of the same character or creature, such as switching gender for
example, or changing the clothing or weapon images being used. These
differing skins then provide either an easy way to render out multiple
spritesheets or, if using a runtime, the ability to change these things
on the fly
In another feature helpful to game developers, Spine allows you to set bounding boxes that can be used for collision and physics in games. This means you can still have accurate collision even as your character’s shape changes throughout their animation cycle.
With the addition of scripts to Spine, images for animating can have their import automated from GIMP and Inkscape. And if you’re working with both Affinity Designer or Photo you can use its built-in Spine batch export feature. With any of these processes you can start with all your body pieces arranged where they should be, as opposed to manually placing them.
Spine also has the ability to export to video, (AVI and Quicktime), meaning you can use it for all kinds of animation purposes as well as game graphics.
DragonBones a completely free program that is very much like Spine. It doesn’t have full feature parity, but it is quite close and given you don’t pay a penny to use it that makes a pretty compelling case. In Spine you’ll need the “Pro” version to access meshes, IK constraints and free form deformation, but these things are included out of the box in DragonBones.
DragonBones, however, doesn’t have as many runtimes as does Spine. It currently caters for C# (can be used with Unity), JS/TypeScript (use with Pixi, Egret), C++ (use with Cocos2d), ActionScript (use with Flash, Starling), SpriteKit and Java.
One of my favorite features in Spine is the “skins” system, and the same type of functionality is available in DragonBones too, it’s just referred to as an “avatar system” instead.
The fact that DragonBones gives free access to all its features features, including meshes and free form deformation, (the ability to stretch and warp images), means you can create some very cool effects with zero cost software:
Setting
up bones is a pretty straight forward experience in DragonBones. It has an auto
binding feature where with the “create bone” tool you can just click in
the image you want a bone to be bound to then drag out to the desired
length. This doesn’t work flawlessly for every image you need to bind, but it
certainly gets you part of the way there.
The dev team behind
DragonBones is Chinese, and while there are English docs you might just
have to read a little carefully as English is the second language of
the writers. However I haven’t found any significant difficulty in
understanding how things work, which I think is helped along by the fact that
tools are placed in the UI in a way that is quite intuitive.
If you’re on Mac or Windows and want to get your skeletal animations rolling with a free application this will be a superb place to start. Note that you will, however, need to login to a free account in order to save your work. Other than that, it’s all open access.
Spriter is another application in the vein of Spine and DragonBones, being focused on creating animations for games. It’s a little different to the above two options however in that it doesn’t include any meshes, but it does include some interesting features that can help with pixel art assets.
Spriter, like DragonBones, doesn’t have as many runtimes as does Spine. But it does cover the major 2D engines with runtimes for Unity, Construct 2 & Game Maker Studio, and language specific runtimes for C#, C++ and JavaScript.
If you’re a pixel artist looking for a way to speed up animations Spriter is a stand out option for you due to its “Pixel art mode”. With this mode active you can only move sprites in whole pixel increments, preventing any blurred half pixels. Additionally, no sampling happens between pixels as they move, so throughout animations your sprites will always retain crisp, blur free pixels.
There is also a great color palette swapping feature that can be used with art in indexed mode, i.e. restricted to a palette with a fixed number of colors, as is most pixel art. With the help of a runtime this makes it possible to provide players with the ability to change a character’s clothing color, hair color, skin color, eye color and so on.
As with Spine and DragonBones, Spriter also offers the ability to swap out the images associated with your bones when using a runtime. In this case the feature is referred to as “character maps”.
And if using Spriter for game development, you can use it to create collision boxes that can be used in game, again as long as you’re using a runtime.
For Linux users a Spriter build is available, however it’s targeted at Ubuntu 14 and relies on Gstreamer 0.10 which isn’t bundled with the software. On older distros or anything based on Ubuntu 16.04 you should be able to easily install the required Gstreamer version manually. However on later distros you may find only Gstreamer 1.0 or higher is in your repos, making Spriter use problematic. Hopefully the developer will be able to update their Linux version soon, otherwise just be aware you may have to work around this issue.
Spriter has both a free version and a “Pro” version for $69, making it an affordable application among its peers.
That said, the free version of Spriter is a solid tool even without the full
feature set of the “Pro” version. It allows you to create skeletal
animations with basic easing control and basic IK so you can really get a
strong feel for the software before deciding whether or not to grab the “Pro” version.
In Creature we have another skeletal animation tool focused on game development. However this one is a little different to the above applications because not only does it include meshes in both its versions, in actual fact everything is a mesh.
In Creature as soon as you import an image it becomes a mesh, as opposed to meshes being something optional you can add if you choose. As everything is mesh-based it means all parts of your image can be deformed, and bones can be used to affect any portion of the mesh as well. Through these features you get the ability to create graphics that have a 3D look to them even when done entirely in 2D.
The standout features of Creature are, in my opinion, in its bone motors and force fields. Bone motors give you ways to control the positioning of your bones procedurally, rather than solely through manual posing. And force fields create environmental influences that can further impact how your motor-driven bones move.
For example, to make hair that can blow in the wind you would add bones to the image meshes that make up the hair on a character, then apply a “bend motor” that would apply the physical properties of real hair, e.g. adding the effect of gravity on the hair, determining how stiff the hair is and so on.
Then once you give the hair appropriate physical properties you can add a force field that simulates wind. This will interact with the bend motor on the hair to create the effect of the hair blowing in the breeze. The same process can be used to make clothing, flags and other flexible materials behave with flowing, physical realism.
On top of in-application force fields, another incredibly cool feature Creature has is the ability to add live bend
physics into a game. This allows elements of your images to bend in a
realistic way according to their movement in game. For example, you might create a fox character whose tail and ears bounce around naturally when they move:
When it comes to runtimes, Creature’s current list includes: C++ (Cocod2d-x, Unreal Engine 4, Godot Engine), Objective-C (Cocod2D), C# (Unity, Monogame), Haxe (Haxe to Flash, HaxeFlixel), Java (libGDX), and JavaScript (Three.js, Babylon.js, Pixi.js, Phaser).
As for what you get in the $99 “Basic” version, you get mesh creation, but not mesh sculpting, optimization and refinement. You get bone motors that can drive bend physics, rope physics, rotation cycles and walking, but you don’t get mesh deformation motors. There’s no path use, but there is spline use. In the “Basic” version you can also swap the sprites associated with meshes, referred to as “skin swapping”.
Right now Creature is available on Mac and Windows, though the lead dev has said Linux support should be coming in the future. Creature has a lot of powerful features that other animation software does not, so it’s definitely an application to try.
OpenToonz is different to the other animation software we’ve covered in that it’s not focused on game dev, but rather on traditional animation for video. Also unlike our other applications OpenToonz is designed for you to be able to draw directly inside the software. OpenToonz is most well known for being the primary software used by beloved animation house Studio Ghibli, as well as being used in Futurama, The Maxx and other popular animated shows and movies.
The animation method in OpenToonz is a different paradigm to the software we’ve talked about so far. There is quite a bit of emphasis on drawing animations frame by frame, though an “auto in-between” tool is available for filling in gaps in your timeline. However, skeletal animation tools are available too, with support for both regular bones as well as meshes.
The included drawing and painting tools are quite robust, with included smoothing / stabilizing and pen pressure support. It also has support for vector based drawing with the ability to modify your art after laying down strokes. Even when working with vectors here the drawing process feels very natural, with no noticeable difference to drawing with raster strokes.
OpenToonz used to be known as Toonz, and since 1993 was a closed source, paid, enterprise level application. Luckily for all of us, it was released as free and open source software in March of 2016. If you’re animating for video it’s a must try.
That’s five awesome alternatives to Adobe software in the animation space, each one with a version available for a one time purchase of under $100, (or free). Let’s quickly summary our applications, and crunch down how to decide which fits you best.
Spine right now is the leader in 2D skeletal animation due to its smooth
workflow, stack of features, and runtimes for just about everything. The full feature set in the “Pro” version would cost you more than our series price cap, and is more expensive than the highest price point on any of our other software. However the “Essentials” version gives you well enough to get on your way animating. If you’re in game dev there’s a good chance this might be the right animation software for you.
If you’re considering Spine and don’t need Linux support, you should
definitely check out DragonBones as part of your decision making
process. It’s not quite as smooth to use as Spine but it is very close.
It doesn’t have all the features of Spine, but it has several of them.
And of course it’s completely free. It does have fewer runtimes available however, so your choice may come down to how important Spine’s extra features are to you, and whether a
runtime is available for your chosen engine and / or coding language.
Spriter is has a free version, and also a “Pro” version that’s cheaper than
Spine’s “Essential” version, so price-wise it stacks up well against Spine. On the other hand its paid version doesn’t have some of features that
DragonBones offers free, which may make it tough to choose over DragonBones. However Spriter does have some great pixel art specific tools that aren’t in other applications and could be very useful for pixel artists. It also has Linux support, which DragonBones does not. So Spriter might be for you if you want those pixel art features, and / or if you’re on Linux and looking for a lower price point than Spine.
Creature is different to the other skeletal animation software we covered in that everything
you work with is a mesh, and it has powerful bone motors and force fields. This means you can do all sorts of cool things like warping images to create pseudo 3D, adding realistic physics effects to images so they look like they’re blowing in the wind or being naturally effected by movement. Creature might be for you if you’re on Mac or Windows and the mesh based animation style appeals to you.
OpenToonz is the standout option if the animation you are producing is for rendered video rather than for games. You can paint directly inside the software in either raster or vector format, with stabilizers and pen pressure support. You can’t do much better than the software used by Studio Ghibli, available completely free of charge.
Of course every one of these applications has a massive list of features that is too long to cover completely in this article, so be sure to try each one out for yourself to see everything they have to offer.
And with that, we’re also wrapping up our series exploring the realms beyond our well
known Adobe applications, looking to see what other cool software might
be out there. Hopefully you’ve found not just some new animation software,
but a whole slew of new software to enjoy. Have fun being creative!
