Now Playing Tracks

Chromium Snapshot/Build Monitor Extension

I have updated the Origional Chromium Snapshot Monitor Extension to work with the new Style URL’s.

I have also now updated it to be compatible with Chrome’s Extension Manifest Version 2 so Everything is working as I’m aware of.


GitHub repo here where you can download zip:

crx download link:

To Install it:

Method 1)

Download .crx from Mediafire and Drag into Chrome’s extension page to install.

Method 2)

Unzip the file from github |> open Chromium |> go to Tools > Extensions |> enable developer mode |> click ‘Load Unpacked Extension’ and find the Chromium-Build-Monitor folder you just unzipped.

ChromeOS - A few more Puzzle Pieces

My First Post which started the Chrome Based Operating System idea one year ago, closed with this:
“My closing thoughts on this are simple, basically every puzzle piece of this that is needed to create this is a reality and already exists, but the pieces are scattered and not arranged into the full beautiful picture yet.”

There have been a few pieces put into place during this past year, the first being NACL , Google’s native client plugin for a way to securely run sandboxed code directly on the CPU, allowing a migration path from assembly(C/C++) native application to run on the metal, enabling functionality by a plug-in similar to ActiveX but securely sandboxed all controlled by Chrome itself.

Currently Nacl is found in the default snapshot directory ( alongside the official Chome snapshot builds and getting build waterfalls in progress. This fact makes me speculate that this is what that have planned:
Currently Nacl is slowly being merged directly into the svn-trunk of Chrome as a separate whole, instead of as a plug-in anymore, having it be merged into their mainline codebase. OR Nacl will serve as the ChomeOS web-kernel allowing a native code interface effectively bridge between the underlying Linux kernel and the content on the internet as web streams.

The second puzzle piece which Google introduced was O3D , this gives access to your GPU directly from inside the browser using JavaScript theoretically allowing execution of OpenGL, DirectX, and even OpenCL code into the GPU right from the browsers interface to the web using JIT Compilation. There are numerous examples and demos which have showcased how O3D works and it’s one of the most important piece to allow wide-spread adoption of a Web-based Operating System. The primary reason of why GPU access is important is a way to really make 3D games like Doom, Crysis, World of Warcraft, and Need for Speed inside the browser streaming from the web as a source, preventing the need to install the game at all.

Another puzzle piece which is a bit more subtle is one for allowing secure authentication right from login, to accessing online secure resources with an open security standard. This features power right now is hiding inside the “Bookmark Sync” capability. Why this is so major, is because you log-in with a Google Account, effectively giving OpenID infrastructure underneith the entire accessable stack . If you can imagine a Business or Company getting an exclusive OPX local login solution which is locally hosted and maintained for company employees. This allows access to internal company property and digital work items in a way a company can control as they please. Or a school to only have OpenID based logins for their own faculty and students creating an entire ecosystem of secure access points all across both companies and educational institutions,
This is of course a slightly minute detail but VERY VERY influential for the possibilities it creates.
The other reason to why the bookmark sync is so important is because it implements a diff algorithm for being able to patch files and dynamically update resources on your local machine as you please based upon a master copy of an official file in a Google Datacenter. This secure diff update can be used to update the whole operating system as you please since all the OS are only just text files containing XML and JavaScript which is web technology for the interface and logic.

Finally the last important addition to Google Chrome’s code and functionality are “extensions”. Extensions are a browser concept which allows expanding the capability of the default browser, to a non-standard use-case, following in Firefox’s footsteps with the most useful and impressive web-changing ability to a home user. Why this is important, is that now Chrome has a XUL or Jet-pack counterpart allowed to do the EXACT same thing. A way to which most people use the extension power is for adding browser chrome enhancements, adding a email checker, or a Twitter posting box. My use cases are adding a native compiled “Start” bar and button directly to the browser, masking your environment of being in a browser completely. Or another case would be to add native OS widgets like a native menu inside of a browser based game, integrated into the game play because you can directly interface with the OS through the browser chrome in a controlled manner of Chrome’s design philosophy.

So during the past year, a few very important and interesting puzzle pieces have been put into place, including one called Wave, which I will leave for another article. Wave itself is… completely different from what most people are believing, Google Wave is a wolf in sheep’s clothing with more power than they are even caring to realize.. but I will adress these issues and clarify Wave’s existence very soon to help fix peoples misconceptions about what they believe to be a communication platform… and the only detail they are not seeing is… a communication platform for what/who.

Hope anyone reading finds this progress report of Chrome helpful, including a few hidden insights most people care to not notice.

The Many-Core Answer - Relativistic Computation

Relativistic Computation
Larger Image here:

This picture illustrates the architecture of the system I have thought of and plan on creating over the next little while on my spare time during University.

As a first pass to explain I’ll start off by saying that the design is a 3-layered system using an OS kernel interface(API) to call for initiating and receiving tasks, which is akin to a traditional stdin and stdout of sorts for the system.

Once inside the input scheduler, this execution controller does NOT work at the threading or task level, but at a bit-stream of opcodes and data level to have the FINEST GRAIN concurrent execution strategy possible with current hardware and techniques. The input scheduler (opcode chunker) takes control of input streams of data as 32 or 64-bit lengths for one instruction in succession so it has as much assembly instruction opcodes as required to saturate each individual CPU core’s pipeline.

Those instructions are then passed from within the “Virtual machine” down into this systems core as true heavyweight OS threads bound to one hardware core each, 1, 2, 4, 8, 16, etc; using one of the Linux VM’s (kvm/qemu) a Windows User-Mode-Scheduler(UMS) or a Multi-platform VM (VMware/VirtualBox) to map 1:1 with threads into the kernel onto hardware.
From there, the whole point of the scheduler has one point in life, making sure each core’s execution pipeline is balanced and saturated across cores to leave as little time idle as hopefully possible until all work is completed.

The actual execution model of the scheduler is the most important conceptual understanding which I am calling “Relativistic Execution”. Whereby one execution is in succession and relative to another only after one full iteration through the currently available resources, which is hopefully explained as such with an increment function example starting from a variable declared 0:

- Core 1 receives a 1 
- Core 2 receives a 2 which is the NEXT CORE included by the scheduler for execution
- Core 3 receives a 3 and finally
- Core 4 receives a 4.

The loop back around to the first core is the most important detail creating the concept:

- Core 1 receives a 5 
- Core 2 receives a 6 
- Core 3 receives a 7 
- Core 4 receives a 8 

This second iteration across the core array as scheduled by the controller now has 4 pillars of numbers: 1:5, 2:6, 3:7, and 4:8 to create the final function of the threads work as +4 instead of the original +1 upon each core as separate entities!
This sets up the actual computation by the output scheduler to instruct the offset computation from its original value for the rest of the functions execution, all the way up to whatever the program code decides, lets say 40.

Step #: 01 - 02 - 03 - 04 - 05 - 06 - 07 - 08 - 09 - 10
Core 1: 01 - 05 - 09 - 13 - 17 - 21 - 25 - 29 - 33 - 37
Core 2: 02 - 06 - 10 - 14 - 18 - 22 - 26 - 30 - 34 - 38
Core 3: 03 - 07 - 11 - 15 - 19 - 23 - 27 - 31 - 35 - 39
Core 4: 04 - 08 - 12 - 16 - 20 - 24 - 28 - 32 - 36 - 40

Each core therefore does exactly 1/4 the work with perfect scheduling with minimal overhead of system scheduling using this model.

The input and output schedulers as I see it are a minimal Virtual Machine abstraction with its own protected memory using input processes as stream ID’s. These would be a good way to schedule through the system from input to the output of the VM for pairing with the original Process(PID) which requested the work to be completed as input.

Oddly enough this method of work distribution is so far below the threading abstraction that sequential code could easily be fed into the system and be scheduled in a concurrent fashion internally which has methods for data fetching into the scheduler for data-dependent computations. The “Silver bullet” which everyone thought did not exist. So I give you this early idea of mine which as school permits, I will slowly code in most likely Haskell, I’m a Haskell developer to the end ;).

I would really enjoy to have feedback upon this idea, and hear all the constructive ideas as well as criticism to whoever may be reading!!

I am HeavensRevenge and various means of contacting me may be found here:

Master Plan with Chrome

Edit: This post was created on September 3rd, 2008 (the immediate days after the Chrome browser was announced)
Many thanks for Google implementing this idea to become ChromeOS :)


Google just made a massive move with chrome, and you all think it’s simply just a browser :P

I have adapted my IRC conversation in the Linux Outlaws IRC room on Freenode to suit a fluently reading presentation of my conversation and thought process with personal enlightenment.


1) Each tab is a thread.

2) Operating systems(Linux, Mac, Windows) And desktop environments (Windows Aero, KDE, Gnome, XFCE) use the exact same technology for task and window switching.

3) What do u think happens if I create a Chrome bootstrapper from grub/boot menu?

Answer: An operating system that’s basically like a kiosk, but you CAN use HTML files on your computer instead of fetching them from the network for as fast as possible speed, you could just patch text files and not update entire binary blobs of an application to change or even debug a view or application if it’s all in HTML/Ajax form. ;)

The blogosphere’s fabled “Google OS” roots are being rooted very firmly right now and no-one outside Google seems to even realize this, and seems to only see the book by its cover and release event to which Chrome is only labeled “yet another” Browser.

A You tube presentation of Chrome had developers and project lead’s explain Chrome on launch day: You tube Release Presentation (

Simply Imagine your whole desktop was as beautiful as any modern web application, all on your hard drive, written all in HTML/Ajax that simply accesses local data on your computer, HTML/Ajax user interfaces that are EyeOS style: that DOES reside in HTML files, and not all binary data with the fact Chrome’s Open source nature is possible to be cross platform, but still allow core parts be compiled per CPU optimized builds.

Oh yes, Chrome itself could be a very good desktop environment, no more Qt, GTK, FLTK… Just HTML/Ajax UI’s which is why they made that V8 Javascript engine so amazingly optimized, that javascript engine is an impressive JIT compiler that actually transforms interpreted Javascript code into machine byte-code!

The fabled Google OS is ACTUALLY possible now since Chrome runs each tab as a process just like an operating system kernel/desktop environment; even with a Linux core running the chrome browser desktop environment, it’s open source extensible nature and future plug-in back-end would make an entire desktop actually plausible!

I hear you say: yeah but HTML isn’t fast enough !!

My reply: the average Windows user just wants their computer to work, without prevention!

Most people have 1-2 CPU cores, and are used to XP & Vista slowing down their computer and have their desktops be entirely latent and are slow as hell anyways, and even so; Chrome’s tabs are an OS process, which can have 1 process per CPU and spawn THOUSANDS of threads internal of each tab!

Also from the URL bar, you could launch local binary programs from just typing /run CCleaner, or /run XChat; some way that can cause a binary to be executed from the “Omnibar” could let existing apps live inside Chrome as a process spawned and managed by Chrome’s internal runtime.

Bottom line is The AVERAGE and the majority of market share DON’T care about Ajax UI’s or Qt UI’s or GTK UI’s, so long as it works and its usable by the person which equals productivity and efficiency. From a developers standpoint(as I am) are plagued by the choice and porting to other UI toolkits; but HTML and Ajax are W3C standardized and can always make new bindings based on the spec.

ALSO people have gotten Doom and Wolfenstein to run fully 3D accelerated/OpenGL in Javascript, Flash and a Java applet in a browser, with a usable frame rate inside the browser for Just-In-Time(JIT ala Haskell and Java) compiled C code to run on the CPU and not in the Webkit/KHTML engine.

The majority of marketshare and people care about eye candy as the result, thus OpenGL+HTML+Speed(V8)=eyecandy/success!

My closing thoughts on this are simple, basically every puzzle piece of this that is needed to create this is a reality and already exists, but the pieces are scattered and not arranged into the full beautiful picture yet.

And thats all for now, if you want to contact me or the people I first told this chain of thought to, check my Google Profile page for numerous methods of contact.

To Tumblr, Love Pixel Union