For sensible commentary about the core mission of Blink and the history leading up to the fork, there’s Alex Russell’s post from Google’s perspective, and Maciej Stachowiak’s comments from Apple’s perspective.

For more detail, there’s the threads between Google (Adam Barth and co.) and Apple (Darin Adler and co.) folks on the WebKit dev mailing lists.

There’s a lot of interesting goals for Blink which I’m excited to see: implementing the DOM in JavaScript; snapshotting in V8; incremental and parallel layout; and multi-process improvements.

I’m also excited to see what Apple is working on, but we’ll need to be patient there as Apple’s style is “show, don’t tell”.

Maciej says it best: “I do not consider Blink to be a hostile fork. I wish the Blink developers good luck & godspeed.”

This is the new PlayStation Video Unlimited service. This PlayStation app runs at a full 60 frames per second (when you see it on a PS3), has tons of 3D graphics effects, full-speed 1080p video playback, and a fluid, hardware accelerated, animated user experience. What you may not know is that this is a web app.

A Web App? On A PlayStation?

The Video Unlimited service is a JavaScript application with a carefully designed runtime platform and very lightweight APIs to access hardware accelerated 3D graphics and shader effects, video playback engine, and other aspects of the PS3 hardware.

Two years ago, I helped start this project at Sony. In six weeks, our team took a working Flash UI prototype and recreated it on a PS3, complete with an early version of the platform, now internally called Trilithium. Alex Bustin, the same UI developer who built the original UI prototype, also wrote the Trilithium port.

The release of Video Unlimited was delayed until now, but Trilithium was used to build another of Sony’s partner’s apps, Hulu Plus for PS3. (See video at the end of this post).

The Trilithium Platform

Trilithium’s strength comes from taking full advantage of the PS3 hardware and existing well-optimized frameworks to do everything from graphics to video playback, leaving the decisions about the high level application to a very flexible JavaScript core API.

We built Trilithium for several reasons:

• Make good use of the complex 8-core + GPU PS3 hardware without killing ourselves.
• Give this power to our UX developers and designers.
• Let partners easily build their own PS3 apps with little knowledge of PS3 architecture.
• Rapidly develop with a flexible environment.

True, there’s no hyperlinking and Trilithium isn’t open (for now).

But Video Unlimited, Hulu Plus, and future Trilithium apps do show what’s possible when you bring the best parts of web and native technology together.

Hulu Plus for PS3

Android’s UX architecture needs work. UI compositing and the view system are both primarily done in software. Garbage collection and async operations frequently block UI rendering.

Android team members are still in denial on the importance of GPU acceleration. They recommend eliminating garbage collection to improve animation performance. They say drawing isn’t the bottleneck and GPU accelerated 2D drawing won’t yield good results:

“It is very naive to think that using the GPU to render text and bitmaps is suddenly going to fix every issue you may see. There are many things that can be done to improve performance of the UI without using the GPU. Notably improving touch events dispatching, reducing garbage collection pauses, asynchronous operations to avoid blocking the UI thread, etc. A one year old NexusOne (and other devices before) is perfectly capable of scrolling a list at close to 60fps (limited by the display’s refresh rate.) Using GPUs to do 2D rendering can introduce other types of inefficiencies (fillrate can be an issue, some primitives like arbitrary shapes are complicated to render with antialiasing, textures need to be uploaded, shaders compiled, etc.) I am not saying we won’t do GPU rendering for the UI (I have worked on it myself a couple of times to test it) but please stop assuming that this is what has to be done right now.”

No one is saying that Android’s “2D primitive drawing” needs GPU acceleration. It’s Android’s view system and animation compositor that needs GPU acceleration. To compare, Core Graphics is still mostly software based while Core Animation is entirely GPU accelerated.

Look at Samsung’s Galaxy S browser. GPU accelerated and tile-based. I’m told it’s a result of Samsung’s PowerVR GPU optimizations. Smooth as butter, runs circles around the Nexus S Gingerbread browser on the same hardware!

Stop executing Dalvik Java VM code on every animation frame. Use the programmable GPU graphics pipeline. Add a scene graph if it makes sense. Run it on a separate thread. You might even get 32-bit graphics along the way.

Android engineers say that better hardware will eventually solve the problem — an insane rationale for the problem. On mobile, power efficiency is king. Throwing dual cores or more GHz at the problem is just going to get you more average performance with zero battery life, and even then, as long as your screen doesn’t get too big.

Wake up, Android team. Windows Phone 7 just lapped you.

Update: Additional discussion on Hacker News.

I believe Apple’s new runtime language successor to be (or very close to) JavaScript with an Objective-C bridge. Here’s why:

1. JavaScript is already one of the iOS platform languages.
2. JavaScriptCore Nitro is fast.
3. JavaScriptCore already bridges with Objective-C.
4. Apple uses JavaScript in deep, key areas: iAd, iTunes 9, Mobile Me
5. DashCode (and PastryKit).

Apple is probably still sorting out:

1. Security + sandboxes. I once asked Doug Crockford what he thought was in JavaScript’s future and this was it.
2. LLVM compilation. For Apple, it makes sense to have a compiled language story that improves JavaScript performance even further via compile-time analysis and optimization, courtesy of LLVM. It’s great for iOS code validation too.
3. Framework design. Apple is known for taking time to try out features and APIs to get them right before publishing them.

Update To Jesper’s point about replacing Objective-C. I believe this successor adds a new level to the Apple language family and doesn’t replace Objective-C. Use JavaScript where appropriate: high level memory safe, dynamic, functional code with a productive, concise syntax. Drop into Objective-C to do performant, memory efficient, or security-privileged things. Drop into C for more speed, more efficiency. It’s turtles all the way down, and in many ways, we’re already there.

Technorati Tags: Apple, LLVM, JavaScript, WebKit, Objective-C

3.3.1 — Applications may only use Documented APIs in the manner prescribed by Apple and must not use or call any private APIs. Applications must be originally written in Objective-C, C, C++, or JavaScript as executed by the iPhone OS WebKit engine, and only code written in C, C++, and Objective-C may compile and directly link against the Documented APIs (e.g., Applications that link to Documented APIs through an intermediary translation or compatibility layer or tool are prohibited).

The thing to understand about Section 3.3.1. is that it is the legal letter of the SDK agreement, but not the desired intent.

Developers are allowed to use SQL for database operations. Developers are encouraged to use GLSL via OpenGL ES 2.0 for fast graphics. SQL and GLSL are not languages in the Objective-C family and they are compiled / interpreted. But they also don’t directly link against the Documented APIs (e.g., there’s no “SELECT subviews FROM UIView”).

Regular expressions and XSLT (ugh) are also similarly permitted.

How I intend to interpret Section 3.3.1., as an independent iPhone developer is as follows: Use Objective-C where it makes the most sense: directly interfacing with the iPhone SDK. When I need different tools to achieve something application specific, like an AI in Lua or printing commands in PostScript, I’m going to use them.

For me personally, I feel that this is what Apple permits and practices in the course of mobile software development.

Practices? Yeah. Have you looked at what iPhone OS itself uses? XML and JSON for data serialization. Nibs, property lists, XSLT in XML domain specific languages. TinyScheme to interpret Scheme code for sandboxed process permissions. hunspell‘s DSL drive the spell check dictionaries.

For sure, Apple has impure motives. But that doesn’t mean they’re wrong. Mobile constraints are different. Battery life and performance matter. A lot.

Use the right tools for the job: Objective-C when talking to iPhone OS. But whatever your application’s brain needs to think different.

Technorati Tags: Apple, iPhone, Flash, programming, languages, mobile

With 52 days to go, and the iPad rumor mill kicking into gear, the question of the day is, “what is the iPad’s mystery icon?”

So, if you think it’s crazy for Apple to be hiding mystery iPad software and hardware, remember that history tends to iRepeat itself.

Personally, I’m looking forward to iChat and Dashboard widgets on iPad.

Update: Felipe makes a good point in the comments. On June 18, 2007, 11 days before the iPhone launch, Apple also upgraded the display hardware from plastic to glass. Glass display parts are $16 today, while camera parts are roughly $10.

Technorati Tags: iPad, YouTube, Apple

• 1440 x 960 10″ multi-touch display – Even multiples of iPhone OS resolution for easy app scaling up
• ARM Cortex A9 CPU – Fast with long battery life
• PowerVR SGX 545 GPU – OpenCL, baby!
• iPhone OS 4.0 – With tablet frameworks and multitasking
• $599 / $699 – Quoting Steve Jobs, “We don’t know how to make a sub-$500 computer that’s not a piece of junk”.
• Names: iBook, Canvas… or iDroid XP 2010 Tablet Edition

Technorati Tags: Apple, tablet, finally, PowerVR, GPU, iPhone

It seems that all rendering is done on the CPU, when it should’ve been on a GPU accelerated compositor or tiled surface manager.

That would save significant battery life (which we haven’t heard anything about) and really kick ass at performance.

Offloading rendering to the GPU also frees you up to, oh, say, reliably detect touch input events.

System on Chip GPU + CPU combos are fairly inexpensive parts these days. Even with a GPU as simple as the first gen iPhone PowerVR MBX lite would’ve had reasonable performance.

UI latency and scrolling performance make all the difference in multi-touch form factor devices. A true multi-touch contender needs to get this right.

Update:

I just realized that JooJoo plays video smoothly at 1080p. So they definitely have a GPU or DSP in there. They’re so close, they just need to get the software up to snuff, maybe with Clutter?

More Reading: On Mobile Phone OS Design and GPUs

Technorati Tags: JooJoo, GPU, CrunchPad, Arrington, TechCrunch

Tablets will have even bigger screens.

If you want your mobile phone OS to matter in 2010, you’d better optimize for rendering graphics on the GPU.

GPUs are far more power efficient and faster at drawing graphics. As mobile device screens get really large, drawing the graphics “old school” on the CPU is moving from “unacceptable” to “impossible” pretty quickly.

Today, Motorola Droid runs at about half the frame rate of iPhone 3GS. The GPU in both is a PowerVR SGX 530 series chip.*

A PowerVR SGX 530 has a fill rate of 200 million pixels per second. That means Motorola Droid’s GPU could theoretically drive 8 full screen refreshes at 60 fps on a Droid-sized (WVGA) screen. All without the CPU’s help.

Parts of Android’s graphics subsystem seem to be GPU accelerated, but more is needed.

Imagine if the Android UX ran at a rock solid 60 fps. Then, I think we’d have something pretty sexy.

I wonder if Apple’s PA Semiconductor unit is designing GPUs instead of CPUs?

* It’s unclear what the exact model of the iPhone 3GS GPU is, and so the exact fill rate is not known… (though if it were, say, a PowerVR SGX 535, its fill rate would be 400 million pixels per second)

Technorati Tags: Android, Droid, Motorola, Apple, Google iPhone, GPU, PowerVR, graphics

Chocolux is a real-time recursive GPU raytracer using four spheres by Auld. Today, Chocolux now can run in your web browser.

The implications of this are pretty mind blowing. WebGL now allows compiled code to run on the GPU. Imagine what games, image processing, and applications will be possible with compiled shaders and general GPU computing (OpenCL?) now in the browser. And with WebGL gaining widespread adoption, it’s going to be here fairly soon.*

For more information about cutting edge fragment shader GPU raytracing and rendering, check out Rendering Worlds with Two Triangles (PDF).

*pending completion of a stable WebGL spec, naturally.

Technorati Tags: OpenGL, WebGL, graphics, GPU, raytracing, OpenCL