diff --git a/External/Jakefile b/External/Jakefile
new file mode 100644
index 000000000..3731900b3
--- /dev/null
+++ b/External/Jakefile
@@ -0,0 +1,63 @@
+#!/usr/bin/env narwhal
+
+var FILE = require("file"),
+    ENV = require("system").env,
+    OS = require("os"),
+    Jake = require("jake");
+    /*,
+    Clean = require("jake/clean");
+*/
+
+require(FILE.absolute("../common.jake"));
+
+$ENVIRONMENT_NARWHAL_PRODUCT = $ENVIRONMENT_DIR
+$ENVIRONMENT_PACKAGES_PRODUCT = FILE.join($ENVIRONMENT_NARWHAL_PRODUCT, 'packages')
+
+$EXTERNALS = ['browserjs', 'jack', 'narwhal', 'ojunit'];
+$PACKAGES = ['browserjs', 'jack'];
+
+function git_export(source, destination)
+{
+    destination = FILE.join(FILE.absolute(destination), '');
+    OS.system("cd " + source + " && git checkout-index -a -f \"--prefix=" + destination + "\"");
+};
+
+filedir ($ENVIRONMENT_DIR, function()
+{
+    FILE.mkdirs($ENVIRONMENT_DIR);
+});
+
+task ("update_submodules", function()
+{
+    if (ENV['NOSUBUP'])
+        return;
+
+    if (executableExists("git"))
+        OS.system("cd .. && git submodule init && git submodule update");
+    else
+        throw "Git not installed";
+});
+
+task ("build", ["update_submodules", $ENVIRONMENT_DIR], function()
+{
+    rm_rf($ENVIRONMENT_NARWHAL_PRODUCT);
+
+    git_export('narwhal', $ENVIRONMENT_NARWHAL_PRODUCT);
+
+    $PACKAGES.forEach(function(aPackage)
+    {
+        git_export(aPackage, FILE.join($ENVIRONMENT_PACKAGES_PRODUCT, aPackage));
+    });
+
+    symlink_executable(FILE.join($ENVIRONMENT_PACKAGES_PRODUCT, 'jack', 'bin', 'jackup'))
+});
+
+//CLOBBER.include($ENVIRONMENT_NARWHAL_PRODUCT)
+
+task ("pull", function()
+{
+    $EXTERNALS.forEach(function(external)
+    {
+        OS.system("cd " + external + " && git pull origin master");
+    });
+});
diff --git a/Foundation/Jakefile b/Foundation/Jakefile
new file mode 100644
index 000000000..cb9233328
--- /dev/null
+++ b/Foundation/Jakefile
@@ -0,0 +1,31 @@
+#!/usr/bin/env narwhal
+print("ok");
+var FILE = require("file"),
+    bundle = require(FILE.absolute("/Users/tolmasky/Development/Cappuccino/Objective-J/commonJS/objective-j/lib/jake/bundletask")).bundle,
+    BundleTask = require(FILE.absolute("/Users/tolmasky/Development/Cappuccino/Objective-J/commonJS/objective-j/lib/jake/bundletask")).BundleTask;
+
+require(FILE.absolute("../common.jake"));
+
+$ENVIRONMENT_PRODUCT = FILE.join($ENVIRONMENT_FRAMEWORKS_DIR, "Foundation");
+$BUILD_PATH = FILE.join($BUILD_DIR, $CONFIGURATION, "Foundation");
+
+task ("build", ["Foundation", $ENVIRONMENT_PRODUCT]);
+
+bundle ("Foundation", function(foundationTask)
+{
+    foundationTask.setBuildIntermediatesPath(FILE.join($BUILD_DIR, "Foundation.build", $CONFIGURATION))
+    foundationTask.setBuildPath(FILE.join($BUILD_DIR, $CONFIGURATION));
+    
+    foundationTask.setIdentifier("com.280n.Foundation");
+    foundationTask.setLicense(BundleTask.License.LGPL_v2_1);
+    foundationTask.setSources(FILE.glob("**/*.j").concat(FILE.glob("*.j")));//terrible!
+    foundationTask.setResources(FILE.glob("Resources/*"));
+});
+
+// Framework in environment directory
+filedir ($ENVIRONMENT_PRODUCT, ["Foundation"], function()
+{
+    cp_r(FILE.join($BUILD_PATH, '.'), $ENVIRONMENT_PRODUCT);
+});
+
+//CLOBBER.include($ENVIRONMENT_PRODUCT)
diff --git a/Jakefile b/Jakefile
new file mode 100644
index 000000000..fa36e88ab
--- /dev/null
+++ b/Jakefile
@@ -0,0 +1,174 @@
+#!/usr/bin/env narwhal
+print("top");
+var FILE = require("file"),
+    ENV = require("system").env,
+    OS = require("os"),
+    jake = require("jake");
+
+require(FILE.absolute("common.jake"));
+
+var subprojects = ["External", "Objective-J", "Foundation", "AppKit", "Tools", "External/ojunit"];
+
+["build", "clean", "clobber"].forEach(function(/*String*/ aTaskName)
+{
+    task (aTaskName, function()
+    {
+        subjake(subprojects, aTaskName);
+    });
+});
+
+global.$DEBUG_ENV                       = FILE.join($BUILD_DIR, 'Debug', 'env');
+global.$RELEASE_ENV                     = FILE.join($BUILD_DIR, 'Release', 'env');
+
+global.$DOXYGEN_CONFIG                  = FILE.join('Tools', 'Documentation', 'Cappuccino.doxygen');
+global.$DOCUMENTATION_BUILD             = FILE.join($BUILD_DIR, 'Documentation');
+
+global.$TOOLS_README                    = FILE.join('Tools', 'READMEs', 'TOOLS-README');
+global.$TOOLS_EDITORS                   = FILE.join('Tools', 'Editors');
+global.$TOOLS_INSTALLER                 = FILE.join('Tools', 'Install', 'install-tools');
+global.$TOOLS_DOWNLOAD                  = FILE.join($BUILD_DIR, 'Cappuccino', 'Tools');
+global.$TOOLS_DOWNLOAD_ENV              = FILE.join($TOOLS_DOWNLOAD, 'objj');
+global.$TOOLS_DOWNLOAD_EDITORS          = FILE.join($TOOLS_DOWNLOAD, 'Editors');
+global.$TOOLS_DOWNLOAD_README           = FILE.join($TOOLS_DOWNLOAD, 'README');
+global.$TOOLS_DOWNLOAD_INSTALLER        = FILE.join($TOOLS_DOWNLOAD, 'install-tools');
+
+global.$STARTER_README                  = FILE.join('Tools', 'READMEs', 'STARTER-README');
+global.$STARTER_DOWNLOAD                = FILE.join($BUILD_DIR, 'Cappuccino', 'Starter');
+global.$STARTER_DOWNLOAD_APPLICATION    = FILE.join($STARTER_DOWNLOAD, 'NewApplication');
+global.$STARTER_DOWNLOAD_README         = FILE.join($STARTER_DOWNLOAD, 'README');
+
+global.$NARWHAL_PACKAGE                 = FILE.join($BUILD_DIR, 'Cappuccino', 'objj');
+
+task ("downloads", ["starter_download", "tools_download", "narwhal_package"]);
+
+filedir ($TOOLS_DOWNLOAD_ENV, ["debug", "release"], function()
+{
+    rm_rf($TOOLS_DOWNLOAD_ENV);
+    cp_r(FILE.join($RELEASE_ENV), $TOOLS_DOWNLOAD_ENV);
+    cp_r(FILE.join($DEBUG_ENV, 'packages', 'objj', 'lib', 'Frameworks'), FILE.join($TOOLS_DOWNLOAD_ENV, 'packages', 'objj', 'lib', 'Frameworks', 'Debug'));
+});
+
+filedir ($TOOLS_DOWNLOAD_EDITORS, [$TOOLS_EDITORS], function()
+{
+    cp_r(FILE.join($TOOLS_EDITORS, '.'), $TOOLS_DOWNLOAD_EDITORS);
+});
+
+filedir ($TOOLS_DOWNLOAD_README, [$TOOLS_README], function()
+{
+    cp($TOOLS_README, $TOOLS_DOWNLOAD_README);
+});
+
+filedir ($TOOLS_DOWNLOAD_INSTALLER, [$TOOLS_INSTALLER], function()
+{
+    cp($TOOLS_INSTALLER, $TOOLS_DOWNLOAD_INSTALLER);
+});
+
+task ("objj_gem", function()
+{
+    subjake('Tools/Rake', "objj_gem");
+});
+
+task ("tools_download", [$TOOLS_DOWNLOAD_ENV, $TOOLS_DOWNLOAD_EDITORS, $TOOLS_DOWNLOAD_README, $TOOLS_DOWNLOAD_INSTALLER, "objj_gem"]);
+
+task ("starter_download", [$STARTER_DOWNLOAD_APPLICATION, $STARTER_DOWNLOAD_README]);
+
+task ("narwhal_package", [$TOOLS_DOWNLOAD_ENV], function()
+{
+  rm_rf($NARWHAL_PACKAGE);
+  cp_r(FILE.join($TOOLS_DOWNLOAD_ENV, 'packages', 'objj'), $NARWHAL_PACKAGE);
+});
+
+task ("deploy", ["downloads", "docs"], function()
+{
+    // copy the docs into the starter pack
+    cp_r(FILE.join($DOCUMENTATION_BUILD, 'html', '.'), FILE.join($STARTER_DOWNLOAD, 'Documentation'));
+
+    var cappuccino_output_path = FILE.join($BUILD_DIR, 'Cappuccino');
+
+    // zip the starter pack
+    var starter_zip_output = FILE.join($BUILD_DIR, 'Cappuccino', 'Starter.zip');
+    rm_rf(starter_zip_output);
+
+    OS.system("cd " + cappuccino_output_path + " && zip -ry -8 Starter.zip Starter");
+
+    // zip the tools pack
+    var tools_zip_output = FILE.join($BUILD_DIR, 'Cappuccino', 'Tools.zip')
+    rm_rf(tools_zip_output);
+
+    OS.system("cd " + cappuccino_output_path + " && zip -ry -8 Tools.zip Tools");
+});
+
+filedir ($STARTER_DOWNLOAD_APPLICATION, [$TOOLS_DOWNLOAD_ENV], function()
+{
+    ENV["PATH"] = FILE.join($TOOLS_DOWNLOAD_ENV, "bin") + ':' + ENV["PATH"];
+
+    rm_rf($STARTER_DOWNLOAD_APPLICATION);
+    FILE.mkdirs($STARTER_DOWNLOAD);
+
+    OS.system("capp gen " + $STARTER_DOWNLOAD_APPLICATION + " -t Application --noconfig");
+//    rake abort if ($? != 0)
+
+    // No tools means no objective-j gem
+    FILE.rm(FILE.join($STARTER_DOWNLOAD_APPLICATION, 'Rakefile'))
+});
+
+filedir ($STARTER_DOWNLOAD_README, [$STARTER_README], function()
+{
+    cp($STARTER_README, $STARTER_DOWNLOAD_README);
+});
+
+task ("install", ["tools_download"], function()
+{
+    var prefix = ENV["prefix"] ? ("--prefix " + ENV["prefix"]) : "";
+
+    OS.system("cd " + $TOOLS_DOWNLOAD + " && sudo sh ./install-tools " + prefix);
+//    rake abort if ($? != 0)
+});
+
+task ("test", ["build"], function()
+{
+    var tests = "'" + FILEList('Tests/**/*.j').join("' '") + "'",
+        build_result = OS.system("ojtest " + tests);
+
+    if (build_result.match(/Test suite failed/i))
+    {
+        print("tests failed, aborting the build");
+        print (build_result);
+        //rake abort
+    }
+    else
+        print(build_result);
+});
+
+task ("docs", function()
+{/*
+    if executable_exists? "doxygen"
+      system %{doxygen #{$DOXYGEN_CONFIG} }
+      rake abort if ($? != 0)
+      
+      rm_rf $DOCUMENTATION_BUILD
+      mv "debug.txt", "Documentation"
+      mv "Documentation", $DOCUMENTATION_BUILD
+    else
+        puts 'doxygen not installed. skipping documentation generation.'
+    end*/
+});
+
+task ("submodules", function()
+{
+/*
+    if executable_exists? "git"
+        system %{git submodule init && git submodule update}
+        rake abort if ($? != 0)
+    else
+        puts "Git not installed"
+        rake abort
+    end
+*/
+});
+
+/*     
+TODO: documentation
+
+TODO: zip/tar.        
+*/
diff --git a/Objective-J/CommonJS/objective-j/lib/jake.js b/Objective-J/CommonJS/objective-j/lib/jake.js
new file mode 100644
index 000000000..f789e31a5
--- /dev/null
+++ b/Objective-J/CommonJS/objective-j/lib/jake.js
@@ -0,0 +1,5 @@
+throw "uh oh";
+print("wha?...");
+exports.BundleTask = require("objective-j/jake/bundletask").BundleTask;
+//exports.FrameworkTask = require("objective-j/jake/frameworktask");
+//exports.ApplicationTask = require("objective-j/jake/applicationtask");
\ No newline at end of file
diff --git a/Objective-J/CommonJS/objective-j/lib/jake/LICENSES/LGPL-v2.1 b/Objective-J/CommonJS/objective-j/lib/jake/LICENSES/LGPL-v2.1
new file mode 100644
index 000000000..9ef3d701d
--- /dev/null
+++ b/Objective-J/CommonJS/objective-j/lib/jake/LICENSES/LGPL-v2.1
@@ -0,0 +1,503 @@
+		  GNU LESSER GENERAL PUBLIC LICENSE
+		       Version 2.1, February 1999
+
+ Copyright (C) 1991, 1999 Free Software Foundation, Inc.
+ 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+[This is the first released version of the Lesser GPL.  It also counts
+ as the successor of the GNU Library Public License, version 2, hence
+ the version number 2.1.]
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+Licenses are intended to guarantee your freedom to share and change
+free software--to make sure the software is free for all its users.
+
+  This license, the Lesser General Public License, applies to some
+specially designated software packages--typically libraries--of the
+Free Software Foundation and other authors who decide to use it.  You
+can use it too, but we suggest you first think carefully about whether
+this license or the ordinary General Public License is the better
+strategy to use in any particular case, based on the explanations below.
+
+  When we speak of free software, we are referring to freedom of use,
+not price.  Our General Public Licenses are designed to make sure that
+you have the freedom to distribute copies of free software (and charge
+for this service if you wish); that you receive source code or can get
+it if you want it; that you can change the software and use pieces of
+it in new free programs; and that you are informed that you can do
+these things.
+
+  To protect your rights, we need to make restrictions that forbid
+distributors to deny you these rights or to ask you to surrender these
+rights.  These restrictions translate to certain responsibilities for
+you if you distribute copies of the library or if you modify it.
+
+  For example, if you distribute copies of the library, whether gratis
+or for a fee, you must give the recipients all the rights that we gave
+you.  You must make sure that they, too, receive or can get the source
+code.  If you link other code with the library, you must provide
+complete object files to the recipients, so that they can relink them
+with the library after making changes to the library and recompiling
+it.  And you must show them these terms so they know their rights.
+
+  We protect your rights with a two-step method: (1) we copyright the
+library, and (2) we offer you this license, which gives you legal
+permission to copy, distribute and/or modify the library.
+
+  To protect each distributor, we want to make it very clear that
+there is no warranty for the free library.  Also, if the library is
+modified by someone else and passed on, the recipients should know
+that what they have is not the original version, so that the original
+author's reputation will not be affected by problems that might be
+introduced by others.
+
+  Finally, software patents pose a constant threat to the existence of
+any free program.  We wish to make sure that a company cannot
+effectively restrict the users of a free program by obtaining a
+restrictive license from a patent holder.  Therefore, we insist that
+any patent license obtained for a version of the library must be
+consistent with the full freedom of use specified in this license.
+
+  Most GNU software, including some libraries, is covered by the
+ordinary GNU General Public License.  This license, the GNU Lesser
+General Public License, applies to certain designated libraries, and
+is quite different from the ordinary General Public License.  We use
+this license for certain libraries in order to permit linking those
+libraries into non-free programs.
+
+  When a program is linked with a library, whether statically or using
+a shared library, the combination of the two is legally speaking a
+combined work, a derivative of the original library.  The ordinary
+General Public License therefore permits such linking only if the
+entire combination fits its criteria of freedom.  The Lesser General
+Public License permits more lax criteria for linking other code with
+the library.
+
+  We call this license the "Lesser" General Public License because it
+does Less to protect the user's freedom than the ordinary General
+Public License.  It also provides other free software developers Less
+of an advantage over competing non-free programs.  These disadvantages
+are the reason we use the ordinary General Public License for many
+libraries.  However, the Lesser license provides advantages in certain
+special circumstances.
+
+  For example, on rare occasions, there may be a special need to
+encourage the widest possible use of a certain library, so that it becomes
+a de-facto standard.  To achieve this, non-free programs must be
+allowed to use the library.  A more frequent case is that a free
+library does the same job as widely used non-free libraries.  In this
+case, there is little to gain by limiting the free library to free
+software only, so we use the Lesser General Public License.
+
+  In other cases, permission to use a particular library in non-free
+programs enables a greater number of people to use a large body of
+free software.  For example, permission to use the GNU C Library in
+non-free programs enables many more people to use the whole GNU
+operating system, as well as its variant, the GNU/Linux operating
+system.
+
+  Although the Lesser General Public License is Less protective of the
+users' freedom, it does ensure that the user of a program that is
+linked with the Library has the freedom and the wherewithal to run
+that program using a modified version of the Library.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.  Pay close attention to the difference between a
+"work based on the library" and a "work that uses the library".  The
+former contains code derived from the library, whereas the latter must
+be combined with the library in order to run.
+
+		  GNU LESSER GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License Agreement applies to any software library or other
+program which contains a notice placed by the copyright holder or
+other authorized party saying it may be distributed under the terms of
+this Lesser General Public License (also called "this License").
+Each licensee is addressed as "you".
+
+  A "library" means a collection of software functions and/or data
+prepared so as to be conveniently linked with application programs
+(which use some of those functions and data) to form executables.
+
+  The "Library", below, refers to any such software library or work
+which has been distributed under these terms.  A "work based on the
+Library" means either the Library or any derivative work under
+copyright law: that is to say, a work containing the Library or a
+portion of it, either verbatim or with modifications and/or translated
+straightforwardly into another language.  (Hereinafter, translation is
+included without limitation in the term "modification".)
+
+  "Source code" for a work means the preferred form of the work for
+making modifications to it.  For a library, complete source code means
+all the source code for all modules it contains, plus any associated
+interface definition files, plus the scripts used to control compilation
+and installation of the library.
+
+  Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running a program using the Library is not restricted, and output from
+such a program is covered only if its contents constitute a work based
+on the Library (independent of the use of the Library in a tool for
+writing it).  Whether that is true depends on what the Library does
+and what the program that uses the Library does.
+  
+  1. You may copy and distribute verbatim copies of the Library's
+complete source code as you receive it, in any medium, provided that
+you conspicuously and appropriately publish on each copy an
+appropriate copyright notice and disclaimer of warranty; keep intact
+all the notices that refer to this License and to the absence of any
+warranty; and distribute a copy of this License along with the
+Library.
+
+  You may charge a fee for the physical act of transferring a copy,
+and you may at your option offer warranty protection in exchange for a
+fee.
+
+  2. You may modify your copy or copies of the Library or any portion
+of it, thus forming a work based on the Library, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) The modified work must itself be a software library.
+
+    b) You must cause the files modified to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    c) You must cause the whole of the work to be licensed at no
+    charge to all third parties under the terms of this License.
+
+    d) If a facility in the modified Library refers to a function or a
+    table of data to be supplied by an application program that uses
+    the facility, other than as an argument passed when the facility
+    is invoked, then you must make a good faith effort to ensure that,
+    in the event an application does not supply such function or
+    table, the facility still operates, and performs whatever part of
+    its purpose remains meaningful.
+
+    (For example, a function in a library to compute square roots has
+    a purpose that is entirely well-defined independent of the
+    application.  Therefore, Subsection 2d requires that any
+    application-supplied function or table used by this function must
+    be optional: if the application does not supply it, the square
+    root function must still compute square roots.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Library,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Library, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote
+it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Library.
+
+In addition, mere aggregation of another work not based on the Library
+with the Library (or with a work based on the Library) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may opt to apply the terms of the ordinary GNU General Public
+License instead of this License to a given copy of the Library.  To do
+this, you must alter all the notices that refer to this License, so
+that they refer to the ordinary GNU General Public License, version 2,
+instead of to this License.  (If a newer version than version 2 of the
+ordinary GNU General Public License has appeared, then you can specify
+that version instead if you wish.)  Do not make any other change in
+these notices.
+
+  Once this change is made in a given copy, it is irreversible for
+that copy, so the ordinary GNU General Public License applies to all
+subsequent copies and derivative works made from that copy.
+
+  This option is useful when you wish to copy part of the code of
+the Library into a program that is not a library.
+
+  4. You may copy and distribute the Library (or a portion or
+derivative of it, under Section 2) in object code or executable form
+under the terms of Sections 1 and 2 above provided that you accompany
+it with the complete corresponding machine-readable source code, which
+must be distributed under the terms of Sections 1 and 2 above on a
+medium customarily used for software interchange.
+
+  If distribution of object code is made by offering access to copy
+from a designated place, then offering equivalent access to copy the
+source code from the same place satisfies the requirement to
+distribute the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  5. A program that contains no derivative of any portion of the
+Library, but is designed to work with the Library by being compiled or
+linked with it, is called a "work that uses the Library".  Such a
+work, in isolation, is not a derivative work of the Library, and
+therefore falls outside the scope of this License.
+
+  However, linking a "work that uses the Library" with the Library
+creates an executable that is a derivative of the Library (because it
+contains portions of the Library), rather than a "work that uses the
+library".  The executable is therefore covered by this License.
+Section 6 states terms for distribution of such executables.
+
+  When a "work that uses the Library" uses material from a header file
+that is part of the Library, the object code for the work may be a
+derivative work of the Library even though the source code is not.
+Whether this is true is especially significant if the work can be
+linked without the Library, or if the work is itself a library.  The
+threshold for this to be true is not precisely defined by law.
+
+  If such an object file uses only numerical parameters, data
+structure layouts and accessors, and small macros and small inline
+functions (ten lines or less in length), then the use of the object
+file is unrestricted, regardless of whether it is legally a derivative
+work.  (Executables containing this object code plus portions of the
+Library will still fall under Section 6.)
+
+  Otherwise, if the work is a derivative of the Library, you may
+distribute the object code for the work under the terms of Section 6.
+Any executables containing that work also fall under Section 6,
+whether or not they are linked directly with the Library itself.
+
+  6. As an exception to the Sections above, you may also combine or
+link a "work that uses the Library" with the Library to produce a
+work containing portions of the Library, and distribute that work
+under terms of your choice, provided that the terms permit
+modification of the work for the customer's own use and reverse
+engineering for debugging such modifications.
+
+  You must give prominent notice with each copy of the work that the
+Library is used in it and that the Library and its use are covered by
+this License.  You must supply a copy of this License.  If the work
+during execution displays copyright notices, you must include the
+copyright notice for the Library among them, as well as a reference
+directing the user to the copy of this License.  Also, you must do one
+of these things:
+
+    a) Accompany the work with the complete corresponding
+    machine-readable source code for the Library including whatever
+    changes were used in the work (which must be distributed under
+    Sections 1 and 2 above); and, if the work is an executable linked
+    with the Library, with the complete machine-readable "work that
+    uses the Library", as object code and/or source code, so that the
+    user can modify the Library and then relink to produce a modified
+    executable containing the modified Library.  (It is understood
+    that the user who changes the contents of definitions files in the
+    Library will not necessarily be able to recompile the application
+    to use the modified definitions.)
+
+    b) Use a suitable shared library mechanism for linking with the
+    Library.  A suitable mechanism is one that (1) uses at run time a
+    copy of the library already present on the user's computer system,
+    rather than copying library functions into the executable, and (2)
+    will operate properly with a modified version of the library, if
+    the user installs one, as long as the modified version is
+    interface-compatible with the version that the work was made with.
+
+    c) Accompany the work with a written offer, valid for at
+    least three years, to give the same user the materials
+    specified in Subsection 6a, above, for a charge no more
+    than the cost of performing this distribution.
+
+    d) If distribution of the work is made by offering access to copy
+    from a designated place, offer equivalent access to copy the above
+    specified materials from the same place.
+
+    e) Verify that the user has already received a copy of these
+    materials or that you have already sent this user a copy.
+
+  For an executable, the required form of the "work that uses the
+Library" must include any data and utility programs needed for
+reproducing the executable from it.  However, as a special exception,
+the materials to be distributed need not include anything that is
+normally distributed (in either source or binary form) with the major
+components (compiler, kernel, and so on) of the operating system on
+which the executable runs, unless that component itself accompanies
+the executable.
+
+  It may happen that this requirement contradicts the license
+restrictions of other proprietary libraries that do not normally
+accompany the operating system.  Such a contradiction means you cannot
+use both them and the Library together in an executable that you
+distribute.
+
+  7. You may place library facilities that are a work based on the
+Library side-by-side in a single library together with other library
+facilities not covered by this License, and distribute such a combined
+library, provided that the separate distribution of the work based on
+the Library and of the other library facilities is otherwise
+permitted, and provided that you do these two things:
+
+    a) Accompany the combined library with a copy of the same work
+    based on the Library, uncombined with any other library
+    facilities.  This must be distributed under the terms of the
+    Sections above.
+
+    b) Give prominent notice with the combined library of the fact
+    that part of it is a work based on the Library, and explaining
+    where to find the accompanying uncombined form of the same work.
+
+  8. You may not copy, modify, sublicense, link with, or distribute
+the Library except as expressly provided under this License.  Any
+attempt otherwise to copy, modify, sublicense, link with, or
+distribute the Library is void, and will automatically terminate your
+rights under this License.  However, parties who have received copies,
+or rights, from you under this License will not have their licenses
+terminated so long as such parties remain in full compliance.
+
+  9. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Library or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Library (or any work based on the
+Library), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Library or works based on it.
+
+  10. Each time you redistribute the Library (or any work based on the
+Library), the recipient automatically receives a license from the
+original licensor to copy, distribute, link with or modify the Library
+subject to these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties with
+this License.
+
+  11. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Library at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Library by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Library.
+
+If any portion of this section is held invalid or unenforceable under any
+particular circumstance, the balance of the section is intended to apply,
+and the section as a whole is intended to apply in other circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  12. If the distribution and/or use of the Library is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Library under this License may add
+an explicit geographical distribution limitation excluding those countries,
+so that distribution is permitted only in or among countries not thus
+excluded.  In such case, this License incorporates the limitation as if
+written in the body of this License.
+
+  13. The Free Software Foundation may publish revised and/or new
+versions of the Lesser General Public License from time to time.
+Such new versions will be similar in spirit to the present version,
+but may differ in detail to address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Library
+specifies a version number of this License which applies to it and
+"any later version", you have the option of following the terms and
+conditions either of that version or of any later version published by
+the Free Software Foundation.  If the Library does not specify a
+license version number, you may choose any version ever published by
+the Free Software Foundation.
+
+  14. If you wish to incorporate parts of the Library into other free
+programs whose distribution conditions are incompatible with these,
+write to the author to ask for permission.  For software which is
+copyrighted by the Free Software Foundation, write to the Free
+Software Foundation; we sometimes make exceptions for this.  Our
+decision will be guided by the two goals of preserving the free status
+of all derivatives of our free software and of promoting the sharing
+and reuse of software generally.
+
+			    NO WARRANTY
+
+  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
+LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
+RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
+FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
+SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
+DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+           How to Apply These Terms to Your New Libraries
+
+  If you develop a new library, and you want it to be of the greatest
+possible use to the public, we recommend making it free software that
+everyone can redistribute and change.  You can do so by permitting
+redistribution under these terms (or, alternatively, under the terms of the
+ordinary General Public License).
+
+  To apply these terms, attach the following notices to the library.  It is
+safest to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least the
+"copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the library's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This library is free software; you can redistribute it and/or
+    modify it under the terms of the GNU Lesser General Public
+    License as published by the Free Software Foundation; either
+    version 2.1 of the License, or (at your option) any later version.
+
+    This library is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+    Lesser General Public License for more details.
+
+    You should have received a copy of the GNU Lesser General Public
+    License along with this library; if not, write to the Free Software
+    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+
+Also add information on how to contact you by electronic and paper mail.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the library, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the
+  library `Frob' (a library for tweaking knobs) written by James Random Hacker.
+
+  <signature of Ty Coon>, 1 April 1990
+  Ty Coon, President of Vice
+
+That's all there is to it!
+
diff --git a/Objective-J/CommonJS/objective-j/lib/jake/LICENSES/MIT b/Objective-J/CommonJS/objective-j/lib/jake/LICENSES/MIT
new file mode 100644
index 000000000..073baf971
--- /dev/null
+++ b/Objective-J/CommonJS/objective-j/lib/jake/LICENSES/MIT
@@ -0,0 +1,19 @@
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
\ No newline at end of file
diff --git a/Objective-J/CommonJS/objective-j/lib/jake/bundletask.js b/Objective-J/CommonJS/objective-j/lib/jake/bundletask.js
new file mode 100644
index 000000000..e8b10fed2
--- /dev/null
+++ b/Objective-J/CommonJS/objective-j/lib/jake/bundletask.js
@@ -0,0 +1,546 @@
+
+var FILE = require("file"),
+    OS = require("os"),
+    Jake = require("jake"),
+    objj = require("objj/objj"),
+    objjc = require("objj/objjc"),
+    plist = require("objj/plist");
+
+var Task = Jake.Task,
+    filedir = Jake.filedir;
+
+exports.bundle = function(aName, aFunction)
+{
+    // No .apply necessary because the parameters aren't variable.
+    return BundleTask.defineTask(aName, aFunction);
+}
+
+function BundleTask(aName, anApplication)
+{
+    Task.apply(this, arguments);
+
+    this._license = null;
+    this._platforms = [BundleTask.Platform.ObjJ];
+    this._sources = null;
+    this._resources = null;
+    this._identifier = null;
+    this._version = 0.1;
+
+    this._productName = this.name();
+    
+    this._buildIntermediatesPath = null;
+    this._buildPath = FILE.cwd();
+
+//    this._nib2cibFlags = [];
+//   this.shouldnib
+}
+
+BundleTask.__proto__ = Task;
+BundleTask.prototype.__proto__ = Task.prototype;
+
+BundleTask.defineTask = function(/*String*/ aName, /*Function*/ aFunction)
+{
+    var bundleTask = Task.defineTask.apply(this, [aName]);
+
+    if (aFunction)
+        aFunction(bundleTask);
+
+    bundleTask.defineTasks();
+
+    return bundleTask;
+}
+
+/*
+        required_attribute :name
+        required_attribute :version
+
+        required_attribute :summary
+        required_attribute :identifier
+        required_attribute :include_nibs, false
+        required_attribute :nib2cib_flags, []
+        required_attribute :platforms, [Platform::ObjJ]
+        required_attribute :type, Bundle::Type::Application
+        
+        # ------------------------- OPTIONAL gemspec attributes.
+        
+        attributes :email, :homepage, :github_project, :description, :license_file, :license
+        attributes :build_path, :intermediates_path
+        attribute :principal_class
+        attribute :index_file
+        attribute :info_plist
+        #    attributes :autorequire, :default_executable
+        #    attribute :platform,               Gem::Platform::RUBY
+        
+        array_attribute :authors
+        attributes :sources
+        array_attribute :resources
+        array_attribute :flags
+        #    array_attribute :test_files
+        #    array_attribute :executables
+        #    array_attribute :extensions
+        #    array_attribute :requirements
+        #    array_attribute :dependencies
+        
+        #read_only :dependencies
+        
+        # ------------------------- ALIASED gemspec attributes.
+        
+        #    attribute_alias_singular :executable,   :executables
+        attribute_alias_singular :author, :authors
+        attribute_alias_singular :flag, :flags
+        attribute_alias_singular :nib2cib_flag, :nib2cib_flags
+        attribute_alias_singular :platform, :platforms
+        #    attribute_alias_singular :require_path, :require_paths
+        #    attribute_alias_singular :test_file,    :test_files
+        
+        # ------------------------- RUNTIME attributes (not persisted).
+        
+        attr_writer :loaded
+        attr_accessor :loaded_from
+        
+
+    this._sources = 
+}
+*/
+
+BundleTask.Platform =   {
+                            "ObjJ"      : "ObjJ",
+                            "Rhino"     : "Rhino",
+                            "Browser"   : "Browser"
+                        };
+
+BundleTask.PLATFORM_DIRECTORIES =   {
+                                        "ObjJ"      : "objj.platform",
+                                        "Rhino"     : "rhino.platform",
+                                        "Browser"   : "browser.platform"
+                                    };
+
+BundleTask.PLATFORM_DEFAULT_FLAGS = {
+                                        "ObjJ"      : [],
+                                        "Rhino"     : ['-DPLATFORM_RHINO'],
+                                        "Browser"   : ['-DPLATFORM_BROWSER', '-DPLATFORM_DOM']
+                                    };
+        
+/*
+if type == Bundle::Type::Application and index_file
+
+                index_file_path = File.join(build_path, File.basename(index_file))
+
+                file_d index_file_path => [index_file] do |t|
+                    cp(index_file, t.name)
+                end
+
+                enhance([index_file_path])
+
+                frameworks_path = File.join(build_path, 'Frameworks')
+
+                file_d frameworks_path do
+                    IO.popen("capp gen -f " + build_path) do |capp|
+                        capp.sync = true
+
+                        while str = capp.gets
+                            puts str
+                        end
+                    end
+                    rake abort if ($? != 0)
+                end
+
+                enhance([frameworks_path])
+            end
+
+*/
+
+BundleTask.prototype.setIdentifier = function(anIdentifier)
+{
+    this._identifier = anIdentifier;
+}
+
+BundleTask.prototype.identifier = function()
+{
+    return this._identifier;
+}
+
+BundleTask.prototype.setVersion = function(aVersion)
+{
+    this._version = aVersion;
+}
+
+BundleTask.prototype.version = function()
+{
+    return this._version;
+}
+
+BundleTask.prototype.setPlatforms = function(platforms)
+{
+    this._platforms = platforms;
+}
+
+BundleTask.prototype.platforms = function()
+{
+    return this._platforms;
+}
+
+BundleTask.prototype.setSources = function(sources)
+{
+    this._sources = sources;
+}
+
+BundleTask.prototype.sources = function()
+{
+    return this._sources;
+}
+
+BundleTask.prototype.setResources = function(resources)
+{
+    this._resources = resources;
+}
+
+BundleTask.prototype.resources = function(resources)
+{
+    this._resources = resources;
+}
+
+BundleTask.prototype.setProductName = function(aProductName)
+{
+    this._productName = aName;
+}
+
+BundleTask.prototype.productName = function()
+{
+    return this._productName;
+}
+
+BundleTask.prototype.setLicense = function(aLicense)
+{
+    this._license = aLicense;
+}
+
+BundleTask.prototype.license = function()
+{
+    return this._license;
+}
+
+BundleTask.prototype.setBuildPath = function(aBuildPath)
+{
+    this._buildPath = aBuildPath;
+}
+
+BundleTask.prototype.buildPath = function()
+{
+    return this._buildPath;
+}
+
+BundleTask.prototype.setBuildIntermediatesPath = function(aBuildPath)
+{
+    this._buildIntermediatesPath = aBuildPath;
+}
+
+BundleTask.prototype.buildIntermediatesPath = function()
+{
+    return this._buildIntermediatesPath || this.buildPath();
+}
+
+BundleTask.prototype.buildProductPath = function()
+{
+    return FILE.join(this.buildPath(), this.productName());
+}
+
+BundleTask.prototype.buildIntermediatesProductPath = function()
+{
+    return this.buildIntermediatesPath() || FILE.join(this.buildPath(), this.productName() + ".build");
+}
+
+BundleTask.prototype.buildProductStaticPathForPlatform = function(aPlatform)
+{
+    return FILE.join(this.buildProductPath(), BundleTask.PLATFORM_DIRECTORIES[aPlatform], this.productName() + ".sj");
+}
+
+BundleTask.prototype.defineTasks = function()
+{
+    this.defineResourceTasks();
+    this.defineSourceTasks();
+    this.defineInfoPlistTask();
+    this.defineLicenseTask();
+    this.defineStaticTask();
+//    CLOBBER.include(build_path)
+}
+
+BundleTask.prototype.packageType = function()
+{
+    return 1;
+}
+
+BundleTask.prototype.infoPlist = function()
+{
+    var infoPlist = new objj.objj_dictionary();
+    //util = require("util"),
+    infoPlist.setValue("CPBundleInfoDictionaryVersion", 6.0);
+    infoPlist.setValue("CPBundleName", this.productName());
+    infoPlist.setValue("CPBundleIdentifier", this.identifier());
+    infoPlist.setValue("CPBundleVersion", this.version());
+    infoPlist.setValue("CPBundlePackageType", this.packageType());
+
+    return infoPlist;
+/*
+    info_plist_path = File.join(build_path, 'Info.plist')
+    new_info_plist = { 'CPBundleName' => name, 'CPBundleIdentifier' => identifier, 'CPBundleInfoDictionaryVersion' => 6.0, 'CPBundleVersion' => version, 'CPBundlePackageType' => Bundle::Type.code_string(type) }
+    
+    new_info_plist['CPBundlePlatforms'] = platforms;
+
+    if info_plist
+        existing_info_plist = Plist::parse_xml(info_plist)
+        new_info_plist = new_info_plist.merge existing_info_plist
+        file_d info_plist_path => [info_plist]
+    end
+
+    if principal_class
+        new_info_plist['CPPrincipalClass'] = principal_class
+    end*/
+}
+
+BundleTask.prototype.defineInfoPlistTask = function()
+{
+    var infoPlistProductPath = FILE.join(this.buildProductPath(), "Info.plist"),
+        bundleTask = this;
+
+    filedir (infoPlistProductPath, function()
+    {
+        plist.writePlist(infoPlistProductPath, bundleTask.infoPlist());
+    });
+
+    this.enhance([infoPlistProductPath]);
+}
+
+BundleTask.License  =   {
+                            LGPL_v2_1   : "LGPL_v2_1",
+                            MIT         : "MIT"
+                        };
+
+var LICENSES_PATH   = FILE.join(FILE.absolute(FILE.dirname(module.path)), "LICENSES"),
+    LICENSE_PATHS   =   {
+                            "LGPL_v2_1" : FILE.join(LICENSES_PATH, "LGPL-v2.1"),
+                            "MIT"       : FILE.join(LICENSES_PATH, "MIT")
+                        };
+print(LICENSE_PATHS.LGPL_v2_1);
+BundleTask.prototype.defineLicenseTask = function()
+{
+    var license = this.license();
+
+    if (!license)
+        return;
+
+    var licensePath = LICENSE_PATHS[license];
+        licenseProductPath = FILE.join(this.buildProductPath(), "LICENSE");
+
+    filedir (licenseProductPath, [licensePath], function()
+    {
+        FILE.copy(licensePath, licenseProductPath);
+    });
+
+    this.enhance([licenseProductPath]);
+}
+/*
+BundleTask.prototype.compact = function(path, *patterns)
+{
+            puts 'Compacting ' + path
+            
+            info_plist_path = File.join(path, 'Info.plist')
+            existing_info_plist = Plist::parse_xml(info_plist_path)
+            
+            absolute_path = File.expand_path(path) + '/'
+
+            patterns = patterns.map { |pattern| "#{path}/#{pattern}" }
+            
+            bundle_name = existing_info_plist['CPBundleName']
+            replaced_files = []
+
+            FileList.new(File.join(path, '**', '*.platform')).each do |platform|
+            
+                FileList.new(File.join(platform, '*.j')) do |list|
+                    
+                    list.include(*patterns)
+                    
+                    executable_path = File.join(platform, bundle_name) + '.sj'
+                    platform_absolute_path = File.expand_path(platform) + '/'
+                    
+                    File.open(executable_path, 'w+') do |executable|
+                    
+                        executable.write '@STATIC;1.0;'
+                        
+                        list.each do |fileName|
+                        
+                            fileName = File.expand_path(fileName)
+
+                            File.open(fileName) do |file|
+                            
+                                if fileName.index(platform_absolute_path) == 0
+                                    fileName = File.expand_path(fileName)[platform_absolute_path.length..-1]
+                                else
+                                    fileName = File.expand_path(fileName)[absolute_path.length..-1]
+                                end
+                                
+                                executable.write "p;#{fileName.length};#{fileName}#{file.read}"
+                                
+                                replaced_files << fileName
+                            end
+                        end
+                    end                    
+                end
+            end
+
+            existing_info_plist['CPBundleReplacedFiles'] = replaced_files.uniq
+            existing_info_plist['CPBundleExecutable'] = bundle_name + '.sj'
+            
+            File.open(info_plist_path, 'w') do |file|
+                file.puts existing_info_plist.to_plist
+            end
+            
+        end
+}
+*/
+BundleTask.prototype.resourcesPath = function()
+{
+    return FILE.join(this.buildProductPath(), "Resources");
+}
+
+BundleTask.prototype.defineResourceTask = function(aResourcePath, aDestinationPath)
+{
+    var extname = FILE.extname(aResourcePath);
+
+    // NOT:
+    // (extname === ".cib" && (FILE.exists(extensionless + '.xib') || FILE.exists(extensionless + '.nib')) ||
+    // (extname === ".xib" || extname === ".nib") && !this.shouldIncludeNibsAndXibs())
+    if ((extname !== ".cib" || !FILE.exists(extensionsless + ".xib") && FILE.exists(extensionless + ".nib")) &&
+        ((extname !== ".xib" && extname !== ".nib") || this.shouldIncludeNibsAndXibs()))
+    {
+        filedir (aDestinationPath, [aResourcePath], function()
+        {
+            cp_r(aResourcePath, aDestinationPath);
+        });
+
+        this.enhance([aDestinationPath]);
+    }
+
+    if (extname === ".xib" || extname === ".nib")
+    {
+        aDestinationPath = FILE.join(FILE.dirname(aDestinationPath), FILE.basename(aDestinationPath, extname)) + ".cib";
+
+        filedir (aDestinationPath, [aResourcePath], function()
+        {
+            OS.system("nib2cib " + aResourcePath + " "  + aCopiedResource + " " + (this._nib2cibFlags || ""));
+        });
+
+        this.enhance([aDestinationPath]);
+    }
+}
+
+BundleTask.prototype.defineResourceTasks = function()
+{
+    if (!this.resources)
+        return;
+
+    var resourcesPath = this.resourcesPath();
+
+    this._resources.forEach(function(aResourcePath)
+    {
+        var baselength = FILE.basename(aResourcePath).length;
+
+        if (FILE.isDirectory(aResourcePath))
+        {
+            FILE.glob(aPath + "/**/*").forEach(function(aSubresourcePath)
+            {
+                this.defineResourceTask(resourcePath, FILE.join(resourcesPath, aSubresourcePath.substring(aSubresourcePath.length - baselength)));
+            }, this);
+        }
+        else
+        {
+            this.defineResourceTask(aResourcePath, FILE.join(resourcesPath, FILE.basename(aResourcePath)));
+        }
+    }, this);
+}
+
+BundleTask.prototype.defineStaticTask = function()
+{
+    this.platforms().forEach(function(/*String*/ aPlatform)
+    {
+        var staticPath = this.buildProductStaticPathForPlatform(aPlatform);
+
+        filedir (staticPath, function(aTask)
+        {
+            print("Creating static file...");
+
+            // No newline!
+            OS.system("echo -n \"@STATIC;1.0;\" > " + staticPath);
+
+            aTask.prerequisites().forEach(function(aFilename)
+            {
+                // Our prerequisites will contain directories due to filedir.
+                if (FILE.isFile(aFilename))
+                    OS.system("cat " + aFilename + " >> " + staticPath);
+            }, this);
+        });
+
+        this.enhance([staticPath]);
+    }, this);
+}
+
+BundleTask.prototype.defineSourceTasks = function()
+{
+    var sources = this.sources();
+
+    if (!sources)
+        return;
+
+    this.platforms().forEach(function(/*String*/ aPlatform)
+    {
+        var platformSources = sources,
+            platformBuildIntermediatesPath = FILE.join(this.buildIntermediatesProductPath(), BundleTask.PLATFORM_DIRECTORIES[aPlatform]),
+            staticPath = this.buildProductStaticPathForPlatform(aPlatform);
+
+        if (!Array.isArray(platformSources))
+            platformSources = platformSources[aPlatform];
+
+        platformSources.forEach(function(/*String*/ aFilename)
+        {
+            // if this file doesn't exist or isn't a .j file, don't preprocess it.
+            if (!FILE.exists(aFilename) || FILE.extname(aFilename) !== '.j')
+                return;
+
+            var compiledPlatformSource = FILE.join(platformBuildIntermediatesPath, FILE.basename(aFilename));
+
+            filedir (compiledPlatformSource, [aFilename], function()
+            {
+                objjc.preprocess(aFilename, compiledPlatformSource);
+            });
+
+            filedir (staticPath, [compiledPlatformSource]);
+
+        }, this);
+    }, this);
+/*
+                    list.each do |fileName|
+                    
+                        fileName = File.expand_path(fileName)
+
+                        File.open(fileName) do |file|
+                        
+                            if fileName.index(platform_absolute_path) == 0
+                                fileName = File.expand_path(fileName)[platform_absolute_path.length..-1]
+                            else
+                                fileName = File.expand_path(fileName)[absolute_path.length..-1]
+                            end
+                            
+                            executable.write "p;#{fileName.length};#{fileName}#{file.read}"
+                            
+                            replaced_files << fileName
+                        end
+                    end
+
+        existing_info_plist['CPBundleReplacedFiles'] = replaced_files.uniq
+        existing_info_plist['CPBundleExecutable'] = bundle_name + '.sj'
+
+    });
+});*/
+}
+
+exports.BundleTask = BundleTask;
diff --git a/Objective-J/CommonJS/objective-j/lib/jake/frameworktask.js b/Objective-J/CommonJS/objective-j/lib/jake/frameworktask.js
new file mode 100644
index 000000000..f996cae24
--- /dev/null
+++ b/Objective-J/CommonJS/objective-j/lib/jake/frameworktask.js
@@ -0,0 +1,23 @@
+
+BundleTask = require("objective-j/bundletask").BundleTask;
+
+function FrameworkTask()
+{
+    BundleTask.apply(this, arguments);
+}
+
+FrameworkTask.__proto__ = BundleTask;
+FrameworkTask.prototype.__proto__ = BundleTask;
+
+FrameworkTask.prototype.packageTask = function()
+{
+    return "FMWK";
+}
+
+exports.FrameworkTask = FrameworkTask;
+
+exports.framework = function(aName, aFunction)
+{
+    // No .apply necessary because the parameters aren't variable.
+    return Framework.defineTask(aName, aFunction);
+}
\ No newline at end of file
diff --git a/Objective-J/CommonJS/objective-j/package.json b/Objective-J/CommonJS/objective-j/package.json
new file mode 100644
index 000000000..7167ec9fe
--- /dev/null
+++ b/Objective-J/CommonJS/objective-j/package.json
@@ -0,0 +1,12 @@
+{
+    "name": "objective-j",
+    "author": "280 North, Inc. (http://280north.com/)",
+    "description": "Objective-J module",
+    "keywords": ["objective-j", "objj", "objective j", "cappuccino"],
+    "contributors": [
+        "Francisco Tolmasky (http://tolmasky.com/)",
+        "Ross Boucher (http://rossboucher.com/)",
+        "Tom Robinson (http://tlrobinson.net/)",
+        "Numerous others (http://contributors.cappuccino.org/)"
+    ]
+}
\ No newline at end of file
diff --git a/Objective-J/Jakefile b/Objective-J/Jakefile
new file mode 100644
index 000000000..84b2a95d9
--- /dev/null
+++ b/Objective-J/Jakefile
@@ -0,0 +1,110 @@
+//#!/usr/bin/env narwhal
+
+var FILE = require("file"),
+    OS = require("os"),
+    Jake = require("jake");
+
+require(FILE.absolute("../common.jake"));
+
+task = Jake.task;
+file = Jake.file;
+filedir = Jake.filedir;
+FileList = Jake.FileList;
+
+/*
+require '../common'
+require 'objective-j'
+require 'rake'
+require 'rake/clean'
+*/
+
+$PRODUCT                = FILE.join($PRODUCT_DIR, 'Objective-J')
+$ENVIRONMENT_PRODUCT    = FILE.join($ENVIRONMENT_FRAMEWORKS_DIR, 'Objective-J')
+$LICENSE_PRODUCT        = FILE.join($PRODUCT, 'LICENSE')
+
+$LICENSE_FILE           = FILE.join($HOME_DIR, 'Tools', 'Rake', 'lib', 'licenses', 'LGPL-v2.1')
+
+$BROWSER_FILE           = FILE.join($PRODUCT, 'Objective-J.js')
+$RHINO_FILE             = FILE.join($PRODUCT, 'rhino.platform', 'Objective-J.js')
+
+task ("Products", [$BROWSER_FILE, $RHINO_FILE, $LICENSE_PRODUCT]);
+Files = ["constants.js", "utilities.js", "json2.js", "runtime.js", "dictionary.js", "plist.js", "file.js", "exception.js", "preprocess.js", "evaluate.js", "bootstrap.js"];
+//Files = new FileList("constants.js", "utilities.js", "json2.js", "runtime.js", "dictionary.js", "plist.js", "file.js", "exception.js", "preprocess.js", "evaluate.js", "bootstrap.js");
+
+if ($CONFIGURATION === "Debug")
+    Files.push("debug.js")//Files.add('debug.js');
+
+filedir ($BROWSER_FILE, Files, function(aTask)
+{
+    build_product(aTask.name(), platform_flags('browser', 'objj'));//ObjectiveJ::Platform::Browser, ObjectiveJ::Platform::ObjJ))
+});
+
+filedir ($RHINO_FILE, Files, function(aTask)
+{
+    flags = platform_flags('rhino', 'objj');//ObjectiveJ::Platform::Rhino, ObjectiveJ::Platform::ObjJ)
+    flags += ' -DRHINO'
+
+    build_product(aTask.name(), flags)
+});
+
+// Framework in environment directory
+filedir ($ENVIRONMENT_PRODUCT, ["Products"], function()
+{
+    rm_rf($ENVIRONMENT_PRODUCT);
+    cp_r($PRODUCT, $ENVIRONMENT_PRODUCT);
+});
+
+filedir ($LICENSE_PRODUCT, [$LICENSE_FILE], function()
+{
+    FILE.copy($LICENSE_FILE, $LICENSE_PRODUCT);
+});
+
+function platform_flags()
+{
+    return "-DPLATFORMS=\"[" + Array.prototype.map.apply(arguments, [function(aPlatform)
+    {
+        return "\\\"" + aPlatform + "\\\"";
+    }]).join(", ") + "]\"";
+}
+
+function build_product(path, flags)
+{
+    var preprocessor = OS.popen("gcc " + flags + " -E -x c -P -");
+
+    OS.system("cat header.txt > " + OS.enquote(path));
+    OS.system("cat " + 
+    Files.filter(function(aName)
+    {
+        return !!aName.match(/\.js$/);
+    }).map(function(aName)
+    {
+        return OS.enquote(aName);
+    }).join(' ') + " | gcc -E -x c -P - >> " + OS.enquote(path));
+    //    rake abort if ($? != 0)
+}
+
+task ("build", ["Products", "build_subprojects", $ENVIRONMENT_PRODUCT]);
+
+task ("clean", ["clean_suprojects"]);
+
+task ("clobber", ["clobber_subprojects"]);
+
+subprojects = ["Tools"];
+
+task ("build_subprojects", function()
+{
+    subjake(subprojects, "build");
+});
+
+task ("clean_suprojects", function()
+{
+    subjake(subprojects, "clean");
+});
+
+task ("clobber_subprojects", function()
+{
+    subjake(subprojects, "clobber");
+});
+
+//CLEAN.include() no temporary files.
+//CLOBBER.include($PRODUCT, $ENVIRONMENT_PRODUCT);
diff --git a/Objective-J/Tools/Jakefile b/Objective-J/Tools/Jakefile
new file mode 100644
index 000000000..3fdd13f05
--- /dev/null
+++ b/Objective-J/Tools/Jakefile
@@ -0,0 +1,24 @@
+#!/usr/bin/env narwhal
+
+var FILE = require("file");
+
+//require("jake/clean");
+require(FILE.absolute("../../common.jake"));
+
+$ENVIRONMENT_NARWHAL_PRODUCT = $ENVIRONMENT_DIR
+$ENVIRONMENT_OBJJ_PRODUCT = FILE.join($ENVIRONMENT_NARWHAL_PRODUCT, 'packages', 'objj')
+
+$EXECUTABLES = ['objj', 'objjc', 'cplutil'];
+
+task ("build", function()
+{
+    rm_rf($ENVIRONMENT_OBJJ_PRODUCT);
+    cp_r("objj", $ENVIRONMENT_OBJJ_PRODUCT);
+
+    $EXECUTABLES.forEach(function(executable)
+    {
+        symlink_executable(FILE.join($ENVIRONMENT_BIN_DIR, executable));
+    });
+});
+
+//CLOBBER.include($ENVIRONMENT_OBJJ_PRODUCT);
diff --git a/common.jake b/common.jake
new file mode 100644
index 000000000..630e48da2
--- /dev/null
+++ b/common.jake
@@ -0,0 +1,208 @@
+
+var ENV = require("system").env,
+    ARGV = require("system").args,
+    FILE = require("file"),
+    OS = require("os"),
+    
+    Jake = require("jake");
+
+global.task = Jake.task;
+global.directory = Jake.directory;
+global.file = Jake.file;
+global.filedir = Jake.filedir;
+
+/*
+def gem_command
+    case RUBY_PLATFORM
+    when /win32/
+        'gem.bat'
+    when /java/
+        'jruby -S gem'
+    else
+        'gem'
+    end
+end
+
+begin
+    require 'rubygems'
+    require 'plist'
+rescue LoadError
+    puts 'Plist gem not installed, installing...'
+    cmd = "#{gem_command} install plist"
+    puts cmd
+    puts %x(#{cmd})
+end
+*/
+// Read in and set up development environment variables.
+if (!ENV["BUILD_PATH"])
+{
+    // Global Cappuccino build directory
+    if (ENV["CAPP_BUILD"])
+        ENV["BUILD_PATH"] = ENV["CAPP_BUILD"];
+
+    // Maintain backwards compatibility with steam.
+    else if(ENV["STEAM_BUILD"])
+        ENV["BUILD_PATH"] = ENV["STEAM_BUILD"];
+
+    // Just build here.
+    else 
+        ENV["BUILD_PATH"] = FILE.join(FILE.dirname(module.path), 'Build');
+}
+
+ENV["BUILD_PATH"] = FILE.absolute(ENV["BUILD_PATH"]);
+
+if (!ENV["CONFIG"])
+    ENV["CONFIG"] = "Release";
+
+global.$CONFIGURATION              = ENV['CONFIG'];
+global.$BUILD_DIR                  = ENV['BUILD_PATH'];
+global.$PRODUCT_DIR                = FILE.join($BUILD_DIR, $CONFIGURATION);
+global.$ENVIRONMENT_DIR            = FILE.join($BUILD_DIR, $CONFIGURATION, 'env');
+global.$ENVIRONMENT_NARWHAL_BIN_DIR= FILE.join($ENVIRONMENT_DIR, 'bin', '');
+global.$ENVIRONMENT_BIN_DIR        = FILE.join($ENVIRONMENT_DIR, 'packages', 'objj', 'bin');
+global.$ENVIRONMENT_LIB_DIR        = FILE.join($ENVIRONMENT_DIR, 'packages', 'objj', 'lib') ;
+global.$ENVIRONMENT_FRAMEWORKS_DIR = FILE.join($ENVIRONMENT_LIB_DIR, 'Frameworks');
+
+global.$HOME_DIR        = FILE.absolute(FILE.dirname(module.path));
+global.$LICENSE_FILE    = FILE.absolute(FILE.join(FILE.dirname(module.path), 'LICENSE'));
+
+global.rm_rf = function(/*String*/ aFilename)
+{
+    try { FILE.rmtree(aFilename); }
+    catch (anException) { }
+}
+
+global.cp_r = function(/*String*/ from, /*String*/ to)
+{
+    FILE.copyTree(from, to);
+}
+
+global.cp = function(/*String*/ from, /*String*/ to)
+{
+    FILE.copy(from, to);
+}
+
+if(!global.COMMON_DO_ONCE)
+{
+    COMMON_DO_ONCE = true
+    
+//    $LOAD_PATH << File.join($HOME_DIR, 'Tools', 'Rake', 'lib')
+    ENV["PATH"] = $ENVIRONMENT_NARWHAL_BIN_DIR + ":" + ENV["PATH"];
+}
+
+//require 'objective-j'
+
+function serializedENV()
+{
+    var serialized = "";
+
+    if (ENV["CONFIG"])
+        serialized += "CONFIG=\"" + ENV["CONFIG"] + "\"";
+
+    if (ENV["BUILD_DIR"])
+        serialized += "BUILD_DIR=\"" + ENV["BUILD_DIR"] + "\"";
+
+    return serialized;
+}
+
+global.subjake = function(/*Array<String>*/ directories, /*String*/ aTaskName)
+{
+    if (!Array.isArray(directories))
+        directories = [directories];
+
+    directories.forEach(function(/*String*/ aDirectory)
+    {
+        if (FILE.isDirectory(aDirectory) && FILE.isFile(FILE.join(aDirectory, "Jakefile")))
+        {
+            OS.system("cd " + aDirectory + " && " + serializedENV() + " " + ARGV[0] + " " + aTaskName);
+        //rake abort if ($? != 0)
+        }
+        else
+            print("warning: subjake missing: " + aDirectory + " (this is not necessarily an error, " + aDirectory + " may be optional)");
+    });
+}
+
+global.executableExists = function(/*String*/ aFileName)
+{
+    return ENV["PATH"].split(':').some(function(/*String*/ aPath)
+    {
+        return FILE.exists(FILE.join(aPath, aFileName));
+    });
+}
+
+$OBJJ_TEMPLATE_EXECUTABLE   = FILE.join($HOME_DIR, 'Tools', 'Rake', 'lib', 'objj-executable')
+/*
+def make_objj_executable(path)
+    cp($OBJJ_TEMPLATE_EXECUTABLE, path)
+    File.chmod(0755, path)
+    symlink_executable(path)
+end
+*/
+global.symlink_executable = function(source)
+{
+    relative = FILE.relative($ENVIRONMENT_NARWHAL_BIN_DIR, source);
+    destination = FILE.join($ENVIRONMENT_NARWHAL_BIN_DIR, FILE.basename(source));
+    FILE.symlink(relative, destination);
+}
+
+task ("build");
+task ("default", "build");
+
+task ("release", function()
+{
+    ENV["CONFIG"] = "Release";
+    spawnJake("build");
+});
+
+task ("debug", function()
+{
+    ENV["CONFIG"] = "Debug";
+    spawnJake("build");
+});
+
+task ("all", ["debug", "release"]);
+
+task ("clean-debug", function()
+{
+    ENV['CONFIG'] = 'Debug'
+    spawnJake("clean");
+});
+
+task ("cleandebug", ["clean-debug"]);
+
+task ("clean-release", function()
+{
+    ENV["CONFIG"] = "Release";
+    spawnJake("clean");
+});
+
+task ("cleanrelease", ["clean-release"]);
+
+task ("clean-all", ["clean-debug", "clean-release"]);
+task ("cleanall", ["clean-all"]);
+
+task ("clobber-debug", function()
+{
+    ENV["CONFIG"] = "Debug";
+    spawnJake("clobber");
+});
+
+task ("clobberdebug", ["clobber-debug"]);
+
+task ("clobber-release", function()
+{
+    ENV["CONFIG"] = "Release";
+    spawnJake("clobber");
+});
+
+task ("clobberrelease", ['clobber-release']);
+
+task ("clobber-all", ["clobber-debug", "clobber-release"]);
+task ("clobberall", ["clobber-all"]);
+
+function spawnJake(/*String*/ aTaskName)
+{
+    OS.system(serializedENV() + " " + ARGV[0] + " " + aTaskName);
+    //system %{#{$serialized_env} #{$0} #{task_name}}
+    //rake abort if ($? != 0)
+}