Mockingbird 1.0 was released today by the folks at Some Character, LLC. If you’ve been following the work Saikat Chakrabarti and Sheena Pakanati have been doing on Mockingbird you’ll know how much effort they’ve put into the project. The duo has spent the last year refining their already excellent beta to create the best mockup and wireframe tool on the Web.

If you’re not familiar with Mockingbird, it’s an application for building and sharing mockups and wireframes built using Cappuccino. The latest release introduces real time collaboration (built with operational transformation, the same technology used in Google Wave). It also includes support for managing your organization complete with permission control. You can try Mockingbird by visiting the demo page.

If you were a beta tester be sure to check your email for a special discount, and visit the website to sign up or if you’re a beta tester upgrade here. Be sure to also read the official announcement.

Mockingbird is an exceptional example of what Cappuccino is capable of, so congratulations again to Saikat and Sheena from the entire Cappuccino community!

Today Michael Villar has released Version 4.0 of PicsEngine, a photo management utility. Version 4.0 has been completely rewritten making use of Cappuccino for the photo administration. This beautiful new application features an entirely custom UI designed by Michael himself.

PicsEngine features a community written HTML5 drag and drop file upload, photo tagging, albums, smart albums searching, geolocation,  and a gallery with mobile versions for the iPhone, iPad, and Android browsers.

We are thrilled to share in the launch of PicsEngine 4.0; it’s truly an amazing product and we’re proud to show off what people are continuing to build with Cappuccino!

Check out PicsEngine here!

Three months ago we were thrilled to announce the introduction of our front end to GitHub Issues. Since then we have worked on specific bugs in the applications and added small features here and there.

Today we are excited to announce the first major revision to our GitHub Issues! Below is a list of all the new features Nick Small and Randy Luecke have worked hard to introduce.

• Editable Issues
• Swap orientation button in the browser version
• Additional keyboard shortcuts
• Additional columns with the ability to show and hide them by right clicking the table header
• Additional search filters
• Additional improvements for keyboard
• Support for previewing issues before you submit them
• Bulk operations on multiple issues at once
• Notifications for unsaved comments and issues
• OAuth
• Full support for tagging

…and of course various bug fixes!

You can view the application by visiting githubissues.heroku.com, or you can download the updated desktop version (read more about how we make this work with NativeHost).

In addition to this new version of the application Randy has worked hard on a browser extension to automatically convert GitHub URLs to use our Cappuccino app.

You can customize it to do any of the following:

• Automatically redirect you from GitHub.com issues to our application
• Prompt you each time you enter an issues page to redirect you to our application
• Click the button in the toolbar to redirect you to our application.

If you are looking at a GitHub repository and click the button in the toolbar you will be redirected to that repository’s issues. If you’re not viewing a repository and click the button in the toolbar you will be redirected to the Issues application where you can select a repository and issue from there.

This plugin has been open source and is available on GitHub, but if you just want to install it you can download it here.

We hope you are as excited about this revision as we are, and we hope this update will make our application even more useful to you!

Community Highlights: Using Cappuccino to build the MemoryMiner Web Viewer

Back with a second post is John Fox, creator of MemoryMiner, a digital storytelling application for Mac OS X. John writes about the steps he took to localize his Cappuccino application, a web viewer for MemoryMiner.

The post comes complete with sample code, and its worth a read if you’re interested in localizing your own applications.

To showcase our new NativeHost technology, we’re proud to announce the brand new GitHub Issues App, written entirely in Cappuccino and available for both desktop and web:

The online version is running on Heroku’s Node.js beta at http://githubissues.heroku.com. If you’re already using GitHub’s Issue tracking feature, then this app will work for you right out of the box. Simply type in your repo’s identifier (username/reponame), and we’ll fetch all the issues for you. You can also log in with your GitHub account to access private repositories.

Open Source

The GitHub Issues app was put together by some truly excellent members of the Cappuccino community, and we’re open sourcing it so that it can serve as an example of how to build and architect a full blown application with Cappuccino and Atlas.

If you don’t have Atlas you can still build the app using the Jakefile in the repo, but you will need Atlas to edit the visual interface files. You can find the source code at http://github.com/280north/issues. So don’t just use it, clone it, patch it, and of course, file bugs!

Cappuccino, NativeHost, Heroku, Node, Oh My!

This app uses and integrates a tremendous amount of new and exciting technology. If you take a look at the source you should find examples on how to do everything from setting up a server to talk to Cappuccino, to optionally deploying your app to the desktop, to talking to other JavaScript libraries:

• We use our brand new NativeHost technology which allows the app to run both on web and desktop.
• We make extensive use of the new tableview component, added in version 0.8
• We integrate with markdown and mustache.js and show you how to intermingle Cappuccino chrome with HTML pages.
• In web mode we use node.js running on Heroku’s new Node Beta.
• We of course use the awesome JSON GitHub Issues API.
• We lay out almost all our UI code visually in Atlas.

If you’d like to help improve the app, or just have questions about the code, make sure to get in touch with us and the rest of the Cappuccino community in the IRC channel or on the mailing list

Thanks!

I wanted to thank everyone who helped bring this app together, including the fantastic guys at the GitHub and Heroku, and of course Randy Luecke and Ludwig Pettersson who actually did the hard work of putting this thing together.

Today we’re adding an exciting new open source component to the repertoire of Cappuccino tools. If you’ve checked out out any of the Atlas betas, you’re probably aware that they’re distributed as a desktop application. What you may not know is that despite this, Atlas is still itself a full fledged Cappuccino application (written in Atlas no less). Atlas has had the ability to create both web and desktop applications from the start, requiring nothing but the click of a button:

The way we’ve accomplished this is with a technology we call NativeHost. NativeHost allows you to take existing Cappuccino applications and with no additional work target them for the desktop. It accomplishes this with an incredibly small and lightweight wrapper around the WebKit browser engine. In this respect, it is similar to a number of existing technologies, including Adobe AIR and Titanium, but that’s where the similarities end.

Why deploy to the desktop?

We believe that applications are moving to the web, but as things stand today, there are still some valid use cases for choosing to distribute a downloadable executable. By allowing you to seamlessly deploy to both desktop and web, we hope to remove one of the blockers keeping people from choosing HTML5 as their next target environment. There are a number of scenarios in which you might decide that the desktop currently fits your needs better:

• When your application needs access to the local filesystem or other native APIs not available to web applications running in browsers.
• When you need enhanced offline access.
• When your target users work in an environment that does not trust the cloud yet (providing a downloadable and not using any web buzz words goes a long way here).
• When you need integration with OS features like the taskbar, dock, application switcher, etc.

This is actually precisely why we created this technology. We were originally planning on releasing Atlas as a cloud-based IDE, but soon discovered our users were much more comfortable currently running it as a desktop app. With NativeHost, we can fulfill these needs today, but switch to the web in the future. Whatever your reasons are, NativeHost aims to provide the best solution for Cappuccino applications.

Why NativeHost?

Before creating NativeHost, we evaluated a number of existing solutions but found that they all suffer from either or both of two major drawbacks:

• Many tools require modification to the existing web app to work on the desktop, or worse, require you to target this environment from the beginning. They aren’t really about making web apps works well on the desktop, but rather for creating desktop apps using web technologies. We see this as the worst of both worlds: creating an application that can’t currently take advantage of all the native platform’s advantages, which simultaneously will require a lot of extra work to deploy on the web.
• The flip side to this is tools that provide only a very thin layer around your web app and thus hardly feel native at all.

Again, we feel that the ultimate distribution platform is the web, and that the desktop is almost a transitional necessity today. So with that in mind, we certainly didn’t want to create a tool that required adding a bunch of new API that won’t work online. However, we also wanted an experience that truly felt good on the desktop. NativeHost is able to accomplish this because it is so tightly integrated with Cappuccino. It provides a seamless experience to both the application developer and end user. The goal is to have any existing Cappuccino app just work on the desktop without requiring any new code. This is manifested in an increasing number of integration points:

• The Cappuccino “main menu” automatically populates the native Mac OS X menu bar. On other platforms it will do what is expected by users on that platform. For example, in a Windows version of NativeHost the menu would be attached the top of individual windows.
• Cappuccino windows (CPWindow) automatically become “native” windows. In the browser Cappuccino windows are typically drawn inside the main browser window. In native host they become real operating system level windows that can be minimized, etc.
• Secure access to the native file system without new API: use existing methods like XMLHttpRequest.
• Cappuccino’s document architecture is integrated with the operating system.
• Operating system open/save panels are used.
• Just like any native application your application can register itself to open specific file types. When the operating system requests that your application open a document that information is passed on to Cappuccino for your application to handle.

Getting up and running with NativeHost

The easiest way to try out NativeHost is with Atlas. Open or create an application, select “Native Desktop” from the “Platform” menu, then press the “Build and Run” button. This will build and launch the current application using NativeHost.

We’ve also recently added support for NativeHost to the Cappuccino build tools. If your “Jakefile” does not contain tasks for “desktop” or “run-desktop” you can copy them out of a freshly generated project’s Jakefile (changing the application name where necessary).

Once you have an application with an updated Jakefile simply execute “jake run-desktop” within the project’s directory to build and launch the application using NativeHost.

NativeHost has some additional features, like the ability to start a webserver in the background to handle tasks using APIs not exposed to WebKit. We’ll talk more about these features in a future post.

Currently NativeHost supports Mac OS X, but we’re working on other platforms. If you’re experienced with developing native applications on other platforms and interested in helping out, feel free to get in touch.

If you have any problems using NativeHost, the Cappuccino community will happily help you out. Join us in the IRC channel, on the mailing list, or file a bug.