portrait

Jonathan Beebe

Mobile app and game developer from California.

Corona SDK Review

UPDATE January 12, 2011: I just published a more recent review, written after a full six months of using and publishing apps with the Corona SDK. After you read the following review (a lot of what you’ll read below is already outdated), please take a moment to read my updated review.



Since I’ve been using the Corona SDK (quite extensively, as you’ll find out) since the end of July (27th), I feel as though I’m pretty qualified to write a full review of the software. But first, there’s a few things I should disclose before I continue:

  • I’m not an Objective-C developer. Although I have some experience in C++, I come from mostly a web-development background (scripting languages, mostly PHP) so I’m a little biased as Corona obviously allows me to develop iPhone apps without the need to learn Objective-C (from what I’ve seen, it’s a pretty tall mountain to climb).

  • With an exception of a little game programming experience, I’ve never really considered myself a desktop app (or mobile app) developer (until now that is).

  • Links within this review are non-affiliated. Meaning, I don’t get a commission for promoting the Corona SDK or sending traffic to the Ansca website.

And a few other things to consider when it comes to my experience with Corona (I’ve been using it for about a month and a half now):

  • I’ve published two games (live in AppStore) using the Corona SDK (that should tell you a lot about it already).

  • Both of those games were originally created (I guess you could say they were ‘prototyped’) using GameSalad (that was before discovering Corona—more info on that later).

  • My wife played a huge role in designing the games and did ALL of the graphics for one of those titles, but on the programming side of things, Corona is what I used. So although working with a partner shortened development time overall, you can still see how Corona saved me a lot of time with the programming (usually the really time-consuming part).

  • At the time of this writing, the Corona SDK was made for iOS and Android development, but I’ve only tested the iOS side of the framework, so keep that in mind throughout this review.

  • I used the Game Edition Alpha/Beta during the course of developing the games, but since GE has all the features of the standard edition, this review will cover both.

  • At the time of this writing, both the Corona SDK Standard and Game Edition are in Beta, so this review won’t cover discrepancies related to beta-level software. But on a side-note, the software is very usable despite that.

Corona SDK Overview

On the official Corona SDK page, one of the first statements you’ll see is:

Create mobile games and apps incredibly fast in our framework. Whether you’re a game developer, web guru, student, or professional, Corona’s elegance and power unlocks your creativity. Publish your apps in seconds to the iPhone, iPod Touch, iPad, and Android.

So in a nutshell, the Corona SDK is a framework (made by Ansca Mobile) that allows you to develop iOS and Android apps/games much faster than you would be able to if you were to go the “default” route (Objective-C and Java).

How does it do this? In short, by allowing you to use a relatively simple, easy-to-learn scripting language called Lua.

What Corona is NOT:

  • An integrated development environment (think: Visual Basic, Delphi, etc. aka “IDE”). Will Ansca add this in the future? I don’t know, but as of right now it doesn’t have one.

  • A set of files that make up a framework for you to import into your Xcode project (e.g. cocos2D). You need to have Xcode installed to use Corona, but you never have to open it up to create an app (and as of September 9, 2010, that’s—without a doubt—perfectly fine).

So then, how does it work?

To put things simply: you use your text-editor of choice to write Lua scripts, place all your project files (scripts, images, and other resources) into a folder, and then simply “Open” that folder with the included Corona Simulator (a Mac OS X app) to either test your app or build it for the device. The process is the same for both iOS and Android apps.

The Review

Before discovering Corona, I never heard of Lua. Apparently it’s pretty popular and widespread, so I don’t know, maybe I’ve been under a rock for a while, but in either case, I was brand new to the language when I originally started the 30-Day trial offer for the SDK.

I was fed up with GameSalad (GS) upon discovering Corona, and was already mentally prepared to break down and climb the Objective-C mountain, so my challenge was this:

"Learn Corona and port a good portion of my existing GS game (Doodle Dash!) before the 30-day trial is over, otherwise, you’re learning Objective-C and moving forward with something like cocos2d."

Like I said, I was just about ready to learn Objective-C, so I didn’t really have the patience to dive into something that might potentially be as limiting as GS and then end up having to go the Objective-C route anyway, so needless to say, my initial expectations for Corona were very high.

The outcome: After 8 days spent learning Lua and putting what I learned into practice by porting over my existing game, I had just about the whole thing completed (with updated graphics and even more features than the original, and WAY better performance). By the 7th of August, I purchased a Corona SDK license, built for distribution and sent the app in for review (which was approved the first-time around).

I learned how to program in Lua and use it with the Corona framework by looking at the included examples, the samples you can download from the official website (Samurai Kitchen, which is a simple-but-complete game example, was a huge help), as well as keeping a browser tab with the API Reference opened at all times.

Although there were a few moments of mild-to-moderate frustration, overall the learning process went very smooth. In fact, it was the fastest I’d ever picked up a new programming language. However, I attribute a lot of that to my existing experience with PHP, Visual Basic, and C++. It undoubtedly would have taken me much longer to learn if I was new to programming altogether.

After submitting Doodle Dash!, we went on to create Dragon’s Keep (which also got approved the first time around), and we are now working on our 3rd Corona-made title which is turning out really great so far (and was not prototyped with GS at all).

And for the record, Doodle Dash! has been downloaded 166,709 times according to iTunes Connect :-) (as of 13th of September) — so that should say something about the level of quality that is possible with Corona, considering Doodle Dash! has only been live for less than a couple of months, and Dragon’s Keep has done relatively well with basically no promotional effort as of yet.

Corona SDK Pros

So throughout my “journey”, the most notable advantages to using the Corona SDK include:

  • Extremely fast development time. Their website says it, and it isn’t a bunch of subjective marketing hype—it’s actually true. If you were to develop iOS apps using Objective-C vs. Corona, your development time would be MUCH higher… and much more frustrating I’d assume (no matter how experienced you are in Objective-C).

  • Lua is easy to learn, and even easier when combined with the Corona framework. This is especially true if you have ANY programming experience. If not, it’s still recommended for a first-time language as well. You can do in ONE line of human-readable code with Corona+Lua that would take more than several lines of code to do with Objective-C.

  • No need to learn Objective-C. You need to download and install the iPhone SDK (free), but you never even have to open Xcode (except when dealing with provisioning profiles, which can be done with the iPhone Configuration Utility so technically, you can use Corona without ever having to open up Xcode).

  • No crazy Xcode projects to manage. Between building the viewer app with GameSalad, and being walked through a few cocos2D tutorials, I know first-hand that managing an Xcode project can be a very involved, and somewhat confusing process. With Corona, your projects are literally text files (Lua scripts) that are placed in a folder—it doesn’t get much simpler than that.

  • In the Game Edition, the Box2D physics engine is very well implemented (even in Game Edition’s beta stage of development), and easy to incorporate into your project.

  • Performance is awesome. As long as you manage your objects well (something that depends on the developer, not Corona), Corona performs extremely well. My games run fine at 30 FPS, but the max can be shifted to 60 FPS (which my projects haven’t called for yet, but in my testing also performed very smoothly). Graphics are 100% OpenGL.

  • No attribution required. Unlike GS (per September 13th, 2010), Corona doesn’t require any attribution within your game (not in the splash screen, credits, nowhere). You’ll see the Ansca logo in Beebe Games credits screens, but that’s only because we choose to have it there, not because we’re required to. Your subscription fee is the only thing they ask for, which is…

  • Very affordable in comparison with other non-Objective-C iOS app development options. On the 15th of this month, the Standard Edition will cost $249/year. The final Game Edition price is yet to be announced, but will obviously cost more because it includes all the standard features. Also note that the yearly membership only affects new apps you create using Corona. Any existing apps already created are yours to keep and distribute despite your membership status (you just can’t submit updates or create new apps with Corona unless you have an active subscription).

  • Although not as flexible as creating apps using Xcode/Objective-C, Corona is still extremely flexible in terms of what you can produce. You have access to a lot of the iPhone’s native features (accelerometer, GPS, photo library, camera, web popups, keyboard, etc.), as well as network/socket support which opens up a whole slew of possibilities in itself. As for game developers, there is currently support for Box2D physics, Facebook/Twitter status updates, and OpenFeint leaderboards and achievements (extremely easy to implement, by the way).

  • Cross-Platform with a minimal amount of effort. I’ve only used Corona for iOS development (so far), but it does Android too… and with the SAME lua scripts. Of course, you have to change a few things here and there, but overall, you can use the same code and compile your apps for both iOS and Android, at least, that’s how it’s going to be once they iron out all the Android details (in it’s beta stage of development, I hear the Android side of Corona is playing catch-up with iOS at this point, but it did get a lot better with Beta 8). Biffy and I plan on porting all of our games over to Android eventually.

  • Great support (community and staff). The user community is fairly small, but is steadily growing and is already very helpful. Whenever I had a problem during the development process (and the learning process), I either found the answer within an existing thread in the Developer Forums, or by starting a new one and asking myself. More often than not, an Ansca staff member will pop in and help out as well. I’ve even seen the Ansca CEO (Carlos Icaza) pop in several times to answer questions and make comments. Carlos was also very responsive to emails I sent regarding some of the concerns I had regarding section 3.3.1 prior to the 9th of September.

  • Training events for those who need hands-on help. From my observations, the Ansca staff are very proactive. They often attend (and host) events (usually in California) where they’ll teach specific Corona or general mobile development concepts. This isn’t guaranteed to continue, but there have been a few events even in the relatively short time I’ve been a Corona SDK subscriber, so I’m pretty sure it will.

  • They honor user suggestions. There are tons of features I see implemented now, that were posted to the suggestions board previously. That says a lot all by itself.

  • If you create an app using the Corona SDK, just let them know (by posting to the appropriate forum board) and they’ll put a link to it in the showcase section of their website! I don’t know about you, but free promotion is always a good thing in my book :-)

  • They offer a free 30-day trial period in case you want to try it out before jumping in and purchasing a subscription (the trial is what convinced me to purchase).

Corona SDK “Cons”

A review wouldn’t be much more than just free marketing without a “negatives” side to the story right? And although I’m obviously a huge Corona SDK fan, I do understand that using it doesn’t come without some sacrifices, so that’s what I’ll go over next. There are really only three that stand out:

1. There is a Price

It’s a product, so it’s not surprising that Ansca Mobile charges a yearly fee to use their SDK, considering that’s the only way for them to get compensated for their efforts (and rightfully so), especially since they don’t charge royalties for the apps created with it. So while it’s understandable (and relatively affordable), it can be considered a drawback for some because of the fact that you’ll have to pay a yearly Corona SDK fee, as well as an Apple Developer fee ($99) to submit iPhone apps.

On top of that, you’re completely at the mercy of Ansca Mobile’s fee structure. If they decide to jack up the prices out of your range in the future, there’s really nothing you can do about it. I trust they won’t do that, but like I said, it can be a drawback that may cause some to just bite the bullet and go the Objective-C route and pay ONLY the Apple Developer fee. Afterall, a corporation is likely to last a lot longer than the duration of it’s staff members’ terms.

With that said, Apple could take more than 30% per app sale, so there’s always drawbacks on some level right?

2. Flexibility is Not Unlimited

I mentioned Corona’s flexibility as a pro before, because it is very flexible (I personally haven’t run into any roadblocks as far as what I wanted to create/implement in our games), but it’s not AS flexible as going the Objective-C route. Here’s a good example of something that IS currently implemented in the Corona SDK, but could just as easily have not been:

OpenFeint. They have their own SDK that you’d normally download and follow their instructions for importing it into your Xcode/Objective-C project. Since you don’t have an Xcode/Objective-C project with Corona, you literally CAN’T use the OpenFeint SDK (or anything else that requires you to include files into your Xcode project).

Instead, Ansca Mobile has to download the SDK and include it in the Corona SDK and then wrap their functions into the Corona framework so you can access it with your Lua code. Even then, not all the features are guaranteed to be implemented. For instance, Corona Game Edition includes support for OpenFeint, but as of right now all you can take advantage of are leaderboards, achievements, and the network save card (OpenFeint + Objective-C does much more than that).

By no means am I complaining, I’m just describing how external libraries fit in with Corona: you’re at the mercy of Ansca Mobile (which isn’t a bad thing right now, as they are a very “merciful" company, but some might consider that a drawback. I personally don’t because Corona does just about everything I need it to at this point).

3. Mac-Only Software (For Now)

I’m a Mac user myself, so once again, not a drawback for me but I can see how it could be for those wanting to develop apps mainly for Android who don’t own a Mac. I could see a Mac-only app being okay if iOS was the only one supported, because you need a Mac for that anyway.

But what about Android developers who are working from Windows or Linux machines, who aren’t interested in iOS development? Putting myself in their shoes, Corona being a cross-platform development tool that’s available for only one platform can definitely be considered a con. I think a Windows version is on their roadmap though, but don’t quote me on that.

Overall I think others in the same position as me will agree: I really can’t view any of those so-called “cons” as limitations because I don’t even know Objective-C, which is the ultimate limitation of all! (without SDK’s like Corona, that is). And if I did learn it, the time I would save by using Corona is worth all of those relatively small downsides in my opinion.

Also know that the cons I mentioned (with an exception of the third one) don’t just apply to the Corona SDK, but to ANY cross-platform framework that allows you to build mobile apps without knowing Objective-C or Java. So if you were looking for one to begin with, then you were most-likely already aware of the two “cons” I’m talking about.

What I’d Like to See Included

This section can’t really be considered part of the review, as many of the things mentioned here could actually end up in the final version of Corona SDK, but since I’m on the subject of Corona I guess I’ll outline my personal features wish-list:

UPDATE OCT 29, 2010: A more updated and descriptive list of my Corona “wishlist” can be found here.

  • Game Center support (for Game Edition, obviously). It’s very new, but it looks like it’s going to be the standard for social gaming on iOS—even the folks at OpenFeint think so.

  • More UI controls. The included UI library really makes things easy when it comes to buttons, etc. but there’s just not much UI included at this point. This isn’t a limitation as you can program everything yourself in Corona, but it would make things even easier if the ui.lua file had more to it.

  • In-App Purchases, In-App Purchases, In-App Purchases! (I hear it’s coming soon though).

  • Some kind of simple interface builder. I’m not asking for an IDE, because personally, I like using BBEdit for my Lua scripts, but sometimes I think things would be easier if I could position some of my objects on the screen, right-click on them, and get their coordinates through some kind of ‘Get Info’ panel instead of having to estimate and then adjust from there. It would really save a lot of time and frustration.

  • An easier method of scene management. Right now, I’ve got my own system for managing different screens (or “scenes” as people from GameSalad would call them) that works great, but I didn’t get it down until my second Corona-made game. It was by far the hardest concept to master, as Lua scripts can easily become long and unorganized. Perhaps just a hands-on tutorial for managing screens with multiple Lua modules would suffice. I personally don’t need it anymore, but I know a lot of new Corona users will. In fact, if nothing develops in this area, I’ll most likely create a tutorial and post it on this blog at some point.

  • Basic bitmap manipulation (at least in Game Edition). It would be nice to be able to change the color of a sprite or image object using code, instead of having to create a separate image for every color t-shirt in my game (for instance).

  • Ability to access the iPhone’s music library (so you can include a ‘custom music’ option in games and allow players to choose their own music). Right now Corona allows you to access a photo library, take screenshots, use the camera, GPS, etc. and that’s great, but music is a big feature on iPhones/iPods, so it would be nice to be able to access that too.

And to say it again, what I just mentioned above were merely suggestions part of my own personal “wishlist”, not gripes or complaints. I’m pretty sure most (if not all) of the above will be included at some point, so I’m not too worried about it.

Conclusion

If you’re looking for a framework that provides faster iPhone/Android app development time with a VERY small learning curve (in contrast with Objective-C and even Java), then Corona is THE BEST option out there. Anything else either costs way too much, is a lot more difficult, has too many limitations, or all of the above.

I’ll say it again: even as beta software, Corona SDK is the BEST when it comes to rapid iPhone app development without Objective-C. And even with experience in Objective-C, Corona can still be considered much better due to how much time it will shave off of the development process. Their website says 90%, and personally, I don’t think that’s an exaggeration.

And if you’re an indie developer with a small development team (like me), then something like the Corona SDK is a MUST in my opinion (at minimum, to save loads of development time), and is without a doubt the best option out there.

If you’re unsure, sign up for the free 30-day trial. I was able to make good use of my trial period, and was even able to build and test on the device (using a developer provisioning profile).

So far the ONLY trial limitations are: you cannot build for distribution (which is the build you send to the AppStore) and a single pop-up message shows stating that it is the trial version when you open your app on the device (doesn’t affect your app negatively, especially since you’ll only be testing your apps in the trial version anyway).

All in all, I give the Corona SDK five out of five stars, and two thumbs up. Well done Ansca Mobile :-)

Further Reading

For more background information, and a better description of my experiences with GameSalad, read my interview on the Ansca blog.

Sep 14, 2010
  1. jonbeebe posted this

Copyright © 2013 Jonathan Beebe