Артем Печкин

Many of the most successful motorcycle builders—the ones running a solid, profitable business—hit on a formula. It’s usually a combination of looks, components and fabrication that works well, and can be endlessly tweaked.

That’s the approach taken by AC Sanctuary, one of Japan’s most renowned builders. Their bikes are a masterclass in proportion, stance and performance. And although they’re expensive, a lot of people are prepared to pay the price.

The AC Sanctuary ‘Real Complete Machine’ concept strips a 70s muscle bike back to its component parts. It effectively gives you a ‘new’ motorcycle, as highly finished as one you’d ride out of a mainstream dealer showroom. This is the very latest build, RCM-242—a Kawasaki Z1 that would stop the traffic more than any contemporary MV Agusta.

The work is extensive, starting with a heavily modified and reinforced frame with a new chain offset. The steering neck, swingarm and bars are proprietary AC Sanctuary items. Handling is elevated still further by a fork from a ZRX1200, and the lightweight 17” wheels are Marchesini.

The blueprinted motor now breathes through Mikuni TMR 36 carburetion. It’s hooked up to a gorgeous Nitro Racing hand-bent steel megaphone exhaust system. The brakes are distinctly modern, with Brembo calipers, Nissin master cylinders and Sunstar disks.

RCM-242 costs ¥ 3.28m, which is around US$37,000. Will it give a modern superbike a run for its money on the racetrack? No. But 99% of the time, it’ll be more than adequate for a skilled rider.

Given the choice between a resto-mod Z1 and a plastic-clad superbike, I’d take the Sanctuary machine any day. Would you?

Bike EXIF delivers the world's best custom motorcycles straight to your inbox, several times a week.

Back in 1974, the Kawasaki Z1 was the most exotic thing on two wheels. And nearly four decades later, it’s lost none of its lustre. This high-performance custom is a collaboration between the Japanese workshop Bull Dock and the British suspension manufacturer Nitron—hence the paintjob in Nitron’s brand colors.

Showcased in Icon’s Limiter magazine, the Z1 is running full Nitron suspension front and rear, hooked up to Bull Dock’s own forged 80s-style ‘Lavorante’ wheels. They’re shod with sticky Bridgestone Battlax S20R rubber. Other mods include an upgraded oil cooler and a custom aluminum tank.

Handling is improved further with a reinforced frame, and the air-cooled 903 cc motor has been bored out to 1015cc. The blueprinted engine is also running Yoshimura ST-1 performance cams and Yoshimura-tweaked Keihin FCR-MJN35 carburetion. The full titanium exhaust, seat, foot controls and swingarm are all high-end custom parts, from Bull Dock’s own Win Mccoy brand.

After all that, it’s reassuring to know that the braking system is a mix of Brembo and Sunstar components.

To see more of Bull Dock’s bikes—plus a swathe of other customs including Icon’s own twin Triumph Tiger 800XCs—grab yourself a free copy of the Icon Limiter print magazine here.

With thanks to our occasional Japanese correspondents, photographer Kyle Drubek and Jason Fullington of AFG Moto.

Bike EXIF is the world's #1 source for custom motorcycles, classic motorcycles and cafe racers. Produced in association with Icon.

Ivan Kuckir sent in a neat library to help Flash developers move to JavaScript.

I have made a graphics library to help people move from Flash to Javascript.  It is something like EaselJS, but unlike EaselJS, all the classes, methods and properties come from Flash and unlike EaselJS, it uses WebGL (GPU) for drawing graphics (it is fast). 

As he says, the API is heavily based on Flash so it will be very familiar to Flash developers.  The library supports many common things, including a scene graph for mouse events over individual elements (not possible with plain WebGL without lots of work), text rendering, images, vectors and more.  It’s all 2d at the moment but rendered on WebGL for speed.  Perhaps it needs a 2d canvas fallback for IE9 though…  The library touts its speed and mobile device support - things most Flash based apps can’t.

There are some library demos, but Ivan has gone even farther and made two fun games with it that certainly show the library’s power and performance.  The first is “Crazy Bugs”, and it is a game where you must move a virtual net around to prevent the bugs from crossing paths.  The second is called “Big Fish” and in this game you are a fish and you have to eat the smaller fish and avoid the bigger fish.  Both are worth a play!

While the library is heavily based on Flash and he says Flash developers will have no trouble picking it up, it does have some documentation of its own for you to get started, and of course the demo source code.  If you’re a Flash developer looking to move to HTML5, this library is certainly worth a look!

SproutCore has always been an interesting project.  It is the application framework behind Apple’s impressive iCloud apps, and the MobileMe ones before that, as well as many other high profile projects.  The SproutCore view layer has gone through many revisions.  At one point it used Ruby templates combined with CSS, and then it switched to a JavaScript only system, which still used embedded HTML and CSS to layout and construct views.

Erich Ocean, a SproutCore contributor since the early days, and others have been hard at work on a new fork of the SproutCore project called Blossom, which reimagines the view layer without the use of any HTML or CSS.  How does it do this?  It renders the entire view structure of your application on a giant HTML5 canvas element.  Perhaps this seems crazy, but it has quite a few benefits over traditional HTML and CSS.

Firstly, it abstracts all browser differences away at the lowest level and makes more complex views that were not possible or very difficult to create with HTML and CSS much more manageable.  Once this has been abstracted, building views on top of it can be much easier for both application developers as well as framework authors, leading to better, more maintainable applications.

Secondly, it’s fast.  Modifying the DOM is about the slowest thing you can do in the browser, and unfortunately it’s probably the most common as well.  There are some performance issues with drawing everything to one huge canvas, so they have separate canvas contexts for each view that then get composited back together at the final step in rendering using drawImage.  This style is akin to the way Core Animation works in Apple’s Cocoa framework, and in fact, GPU accelerated 3D transitions are possible in Blossom as well.

Obviously, when not rendering to HTML and CSS, you have to manage everything yourself, from hit testing of views, to all the nuances of text handling including all the platform native keyboard shortcuts.

This isn’t the first time we’ve seen an attempt to create an entirely canvas based view pipeline, but it certainly the most ambitious.  Back in 2009 when Dion Almaer and Ben Galbraith were working at Mozilla on the Bespin code editor (now Ace), they also started work on a framework they called Thunderhead, which worked like this.  Ultimately, they didn’t get too far on it, so Blossom seems to be the next step in proving if this approach is viable.

Of course, Blossom is a fork of the original SproutCore project, and so it brings over all the foundation frameworks that underly it including the famous support for bindings and observers that have now made the other more lightweight fork of SproutCore, Ember.js popular as well.  It also contains the datastore frameworks as well as some new build tools written entirely in JavaScript using Node.js.

The number one question people ask about creating applications in canvas is about accessibility.  Screen readers don’t know what’s going on within a canvas element, but luckily, the framework can take advantage of WAI ARIA by embedding a DOM subtree inside the canvas element specifically to enable this, however nothing is rendered via this DOM and it is invisible to the user.  I’ve long thought that JavaScript needed an API to directly communicate with assistive technologies, and perhaps frameworks like this will shed light on a use case for that.

So how does this perform on mobile browsers?  Unfortunately, the answer is not so well, so mobile browsers are unsupported.  However, Blossom does have another strategy for mobile, which is to package up the applications as native iOS and Android apps.  This doesn’t mean simply wrapping the application in a WebView and shipping.  For performance reasons, and since the canvas API is easily reproducible on these platforms, all rendering will use the native rendering pipeline on those platforms.  This is the result of not having any DOM to worry about, all you need is a JS engine, and seems like it could be pretty cool!

As for desktop browsers, Blossom will run on all modern browsers supporting the canvas element, which in practice means everything except IE8 and below.  IE9 is not currently working (IE10 is), but there is no reason why it couldn’t in the future.

SproutCore has turned into many things, and there are now at least 3 different frameworks based directly on it.  The original SproutCore 1.x line is still in use at Apple and many other places, but SproutCore 2.0, now Ember.js is perhaps gaining even more traction as a lightweight version of the framework with only the most powerful features baked in.  Blossom joins the party, staying much more heavyweight than say Ember, but also containing a lot more features and a powerful view layer for desktop-class applications in the browser - SproutCore’s original goal.

Blossom has just reached beta status and if you were a hardcore SproutCore 1.x developer you should definitely check it out.  There is also lots of cool code to read in the Blossom repo on Github, and some demos to check out if you install it on your own machine.  A full release for end users is scheduled for May at JSConf.  There’s lots of cool stuff coming down the pipeline for Blossom, including a Cassowary constraint solver that will be useful for layout, so we’ll be watching for sure!