diff --git a/.gitignore b/.gitignore
index d9d37c96f..a0e0b48d8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -6,5 +6,4 @@
 /website/build
 .DS_Store
 .vagrant
-Vagrantfile
 test/.env
diff --git a/.travis.yml b/.travis.yml
index 1a81bef54..4fac7ab93 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -2,20 +2,14 @@ language: go
 
 go:
     - 1.2
+    - 1.3
     - tip
 
-install: make deps
+install: make updatedeps
 script:
-    - go test ./...
+    - GOMAXPROCS=2 make test
     #- go test -race ./...
 
-notifications:
-    irc:
-        channels:
-            - "chat.freenode.net#packer-tool"
-        on_success: change
-        on_failure: always
-
 matrix:
     allow_failures:
         - go: tip
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2927455c8..f24003bea 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,9 +1,238 @@
-## 0.6.0 (unreleased)
+## 0.8.0 (unreleased)
+
+
+
+## 0.7.2 (October 28, 2014)
+
+FEATURES:
+
+  * builder/digitalocean: API V2 support. [GH-1463]
+  * builder/parallels: Don't depend on _prl-utils_ [GH-1499]
+
+IMPROVEMENTS:
+
+  * builder/amazon/all: Support new AWS Frankfurt region.
+  * builder/docker: Allow remote `DOCKER_HOST`, which works as long as
+      volumes work. [GH-1594]
+  * builder/qemu: Can set cache mode for main disk. [GH-1558]
+  * builder/qemu: Can build from pre-existing disk. [GH-1342]
+  * builder/vmware: Can specify path to Fusion installation with environmental
+      variable `FUSION_APP_PATH`. [GH-1552]
+  * builder/vmware: Can specify the HW version for the VMX. [GH-1530]
+  * builder/vmware/esxi: Will now cache ISOs/floppies remotely. [GH-1479]
+  * builder/vmware/vmx: Source VMX can have a disk connected via SATA. [GH-1604]
+  * post-processors/vagrant: Support Qemu (libvirt) boxes. [GH-1330]
+  * post-processors/vagrantcloud: Support self-hosted box URLs.
+
+BUG FIXES:
+
+  * core: Fix loading plugins from pwd. [GH-1521]
+  * builder/amazon: Prefer token in config if given. [GH-1544]
+  * builder/amazon/all: Extended timeout for waiting for AMI. [GH-1533]
+  * builder/virtualbox: Can read VirtualBox version on FreeBSD. [GH-1570]
+  * builder/virtualbox: More robust reading of guest additions URL. [GH-1509]
+  * builder/vmware: Always remove floppies/drives. [GH-1504]
+  * builder/vmware: Wait some time so that post-VMX update aren't
+      overwritten. [GH-1504]
+  * builder/vmware/esxi: Retry power on if it fails. [GH-1334]
+  * builder/vmware-vmx: Fix issue with order of boot command support [GH-1492]
+  * builder/amazon: Extend timeout and allow user override [GH-1533]
+  * builder/parallels: Ignore 'The fdd0 device does not exist' [GH-1501]
+  * builder/parallels: Rely on Cleanup functions to detach devices [GH-1502]
+  * builder/parallels: Create VM without hdd and then add it later [GH-1548]
+  * builder/parallels: Disconnect cdrom0 [GH-1605]
+  * builder/qemu: Don't use `-redir` flag anymore, replace with
+      `hostfwd` options. [GH-1561]
+  * builder/qmeu: Use `pc` as default machine type instead of `pc-1.0`.
+  * providers/aws: Ignore transient network errors. [GH-1579]
+  * provisioner/ansible: Don't buffer output so output streams in. [GH-1585]
+  * provisioner/ansible: Use inventory file always to avoid potentially
+      deprecated feature. [GH-1562]
+  * provisioner/shell: Quote environmental variables. [GH-1568]
+  * provisioner/salt: Bootstrap over SSL. [GH-1608]
+  * post-processors/docker-push: Work with docker-tag artifacts. [GH-1526]
+  * post-processors/vsphere: Append "/" to object address. [GH-1615]
+
+## 0.7.1 (September 10, 2014)
+
+FEATURES:
+
+  * builder/vmware: VMware Fusion Pro 7 is now supported. [GH-1478]
+
+BUG FIXES:
+
+  * core: SSH will connect slightly faster if it is ready immediately.
+  * provisioner/file: directory uploads no longer hang. [GH-1484]
+  * provisioner/file: fixed crash on large files. [GH-1473]
+  * scripts: Windows executable renamed to packer.exe. [GH-1483]
+
+## 0.7.0 (September 8, 2014)
+
+BACKWARDS INCOMPATIBILITIES:
+
+  * The authentication configuration for Google Compute Engine has changed.
+      The new method is much simpler, but is not backwards compatible.
+      `packer fix` will _not_ fix this. Please read the updated GCE docs.
+
+FEATURES:
+
+  * **New Post-Processor: `compress`** - Gzip compresses artifacts with files.
+  * **New Post-Processor: `docker-save`** - Save an image. This is similar to
+      export, but preserves the image hierarchy.
+  * **New Post-Processor: `docker-tag`** - Tag a created image.
+  * **New Template Functions: `upper`, `lower`** - See documentation for
+      more details.
+  * core: Plugins are automatically discovered if they're named properly.
+      Packer will look in the PWD and the directory with `packer` for
+      binaries named `packer-TYPE-NAME`.
+  * core: Plugins placed in `~/.packer.d/plugins` are now automatically
+      discovered.
+  * builder/amazon: Spot instances can now be used to build EBS backed and
+      instance store images. [GH-1139]
+  * builder/docker: Images can now be committed instead of exported. [GH-1198]
+  * builder/virtualbox-ovf: New `import_flags` setting can be used to add
+      new command line flags to `VBoxManage import` to allow things such
+      as EULAs to be accepted. [GH-1383]
+  * builder/virtualbox-ovf: Boot commands and the HTTP server are supported.
+      [GH-1169]
+  * builder/vmware: VMware Player 6 is now supported. [GH-1168]
+  * builder/vmware-vmx: Boot commands and the HTTP server are supported.
+      [GH-1169]
+
+IMPROVEMENTS:
+
+  * core: `isotime` function can take a format. [GH-1126]
+  * builder/amazon/all: `AWS_SECURITY_TOKEN` is read and can also be
+      set with the `token` configuration. [GH-1236]
+  * builder/amazon/all: Can force SSH on the private IP address with
+      `ssh_private_ip`. [GH-1229]
+  * builder/amazon/all: String fields in device mappings can use variables. [GH-1090]
+  * builder/amazon-instance: EBS AMIs can be used as a source. [GH-1453]
+  * builder/digitalocean: Can set API URL endpoint. [GH-1448]
+  * builder/digitalocean: Region supports variables. [GH-1452]
+  * builder/docker: Can now specify login credentials to pull images.
+  * builder/docker: Support mounting additional volumes. [GH-1430]
+  * builder/parallels/all: Path to tools ISO is calculated automatically. [GH-1455]
+  * builder/parallels-pvm: `reassign_mac` option to choose wehther or not
+      to generate a new MAC address. [GH-1461]
+  * builder/qemu: Can specify "none" acceleration type. [GH-1395]
+  * builder/qemu: Can specify "tcg" acceleration type. [GH-1395]
+  * builder/virtualbox/all: `iso_interface` option to mount ISO with SATA. [GH-1200]
+  * builder/vmware-vmx: Proper `floppy_files` support. [GH-1057]
+  * command/build: Add `-color=false` flag to disable color. [GH-1433]
+  * post-processor/docker-push: Can now specify login credentials. [GH-1243]
+  * provisioner/chef-client: Support `chef_environment`. [GH-1190]
+
+BUG FIXES:
+
+  * core: nicer error message if an encrypted private key is used for
+      SSH. [GH-1445]
+  * core: Fix crash that could happen with a well timed double Ctrl-C.
+      [GH-1328] [GH-1314]
+  * core: SSH TCP keepalive period is now 5 seconds (shorter). [GH-1232]
+  * builder/amazon-chroot: Can properly build HVM images now. [GH-1360]
+  * builder/amazon-chroot: Fix crash in root device check. [GH-1360]
+  * builder/amazon-chroot: Add description that Packer made the snapshot
+      with a time. [GH-1388]
+  * builder/amazon-ebs: AMI is deregistered if an error. [GH-1186]
+  * builder/amazon-instance: Fix deprecation warning for `ec2-bundle-vol`
+      [GH-1424]
+  * builder/amazon-instance: Add `--no-filter` to the `ec2-bundle-vol`
+      command by default to avoid corrupting data by removing package
+      manager certs. [GH-1137]
+  * builder/amazon/all: `delete_on_termination` set to false will work.
+  * builder/amazon/all: Fix race condition on setting tags. [GH-1367]
+  * builder/amazon/all: More desctriptive error messages if Amazon only
+      sends an error code. [GH-1189]
+  * builder/docker: Error if `DOCKER_HOST` is set.
+  * builder/docker: Remove the container during cleanup. [GH-1206]
+  * builder/docker: Fix case where not all output would show up from
+      provisioners.
+  * builder/googlecompute: add `disk_size` option. [GH-1397]
+  * builder/googlecompute: Auth works with latest formats on Google Cloud
+      Console. [GH-1344]
+  * builder/openstack: Region is not required. [GH-1418]
+  * builder/parallels-iso: ISO not removed from VM after install [GH-1338]
+  * builder/parallels/all: Add support for Parallels Desktop 10 [GH-1438]
+  * builder/parallels/all: Added some navigation keys [GH-1442]
+  * builder/qemu: If headless, sdl display won't be used. [GH-1395]
+  * builder/qemu: Use `512M` as `-m` default. [GH-1444]
+  * builder/virtualbox/all: Search `VBOX_MSI_INSTALL_PATH` for path to
+      `VBoxManage` on Windows. [GH-1337]
+  * builder/virtualbox/all: Seed RNG to avoid same ports. [GH-1386]
+  * builder/virtualbox/all: Better error if guest additions URL couldn't be
+      detected. [GH-1439]
+  * builder/virtualbox/all: Detect errors even when `VBoxManage` exits
+      with a zero exit code. [GH-1119]
+  * builder/virtualbox/iso: Append timestamp to default name for parallel
+      builds. [GH-1365]
+  * builder/vmware/all: No more error when Packer stops an already-stopped
+      VM. [GH-1300]
+  * builder/vmware/all: `ssh_host` accepts templates. [GH-1396]
+  * builder/vmware/all: Don't remount floppy in VMX post step. [GH-1239]
+  * builder/vmware/vmx: Do not re-add floppy disk files to VMX [GH-1361]
+  * builder/vmware-iso: Fix crash when `vnc_port_min` and max were the
+      same value. [GH-1288]
+  * builder/vmware-iso: Finding an available VNC port on Windows works. [GH-1372]
+  * builder/vmware-vmx: Nice error if Clone is not supported (not VMware
+      Fusion Pro). [GH-787]
+  * post-processor/vagrant: Can supply your own metadata.json. [GH-1143]
+  * provisioner/ansible-local: Use proper path on Windows. [GH-1375]
+  * provisioner/file: Mode will now be preserved. [GH-1064]
+
+## 0.6.1 (July 20, 2014)
+
+FEATURES:
+
+  * **New post processor:** `vagrant-cloud` - Push box files generated by
+    vagrant post processor to Vagrant Cloud. [GH-1289]
+  * Vagrant post-processor can now packer Hyper-V boxes.
+
+IMPROVEMENTS:
+
+  * builder/amazon: Support for enhanced networking on HVM images. [GH-1228]
+  * builder/amazon-ebs: Support encrypted EBS volumes [GH-1194]
+  * builder/ansible: Add `playbook_dir` option. [GH-1000]
+  * builder/openstack: Add ability to configure networks. [GH-1261]
+  * builder/openstack: Skip certificate verification. [GH-1121]
+  * builder/parallels/all: Add ability to select interface to connect to.
+  * builder/parallels/pvm: Support `boot_command`. [GH-1082]
+  * builder/virtualbox/all: Attempt to use local guest additions ISO
+      before downloading from internet. [GH-1123]
+  * builder/virtualbox/ovf: Supports `guest_additions_mode` [GH-1035]
+  * builder/vmware/all: Increase cleanup timeout to 120 seconds [GH-1167]
+  * builder/vmware/all: Add `vmx_data_post` for modifying VMX data
+      after shutdown. [GH-1149]
+  * builder/vmware/vmx: Supports tools uploading. [GH-1154]
+
+BUG FIXES:
+
+  * core: `isotime` is the same time during the entire build. [GH-1153]
+  * builder/amazon-common: Sort AMI strings before outputting [GH-1305]
+  * builder/amazon: User data can use templates/variables. [GH-1343]
+  * builder/amazon: Can now build AMIs in GovCloud.
+  * builder/null: SSH info can use templates/variables. [GH-1343]
+  * builder/openstack: Workaround for gophercloud.ServerById crashing [GH-1257]
+  * builder/openstack: Force IPv4 addresses from address pools [GH-1258]
+  * builder/parallels: Do not delete entire CDROM device. [GH-1115]
+  * builder/parallels: Errors while creating floppy disk. [GH-1225]
+  * builder/parallels: Errors while removing floppy drive. [GH-1226]
+  * builder/virtualbox-ovf: Supports guest additions options. [GH-1120]
+  * builder/vmware-iso: Fix esx5 path separator in windows. [GH-1316]
+  * builder/vmware: Remote ESXi builder now uploads floppy. [GH-1106]
+  * builder/vmware: Remote ESXi builder no longer re-uploads ISO every
+      time. [GH-1244]
+  * post-processor/vsphere: Accept DOMAIN\account usernames [GH-1178]
+  * provisioner/chef-*: Fix remotePaths for Windows [GH-394]
+
+## 0.6.0 (May 2, 2014)
 
 FEATURES:
 
   * **New builder:** `null` - The null builder does not produce any
     artifacts, but is useful for debugging provisioning scripts. [GH-970]
+  * **New builder:** `parallels-iso` and `parallels-pvm` - These can be
+    used to build Parallels virtual machines. [GH-1101]
   * **New provisioner:** `chef-client` - Provision using a the `chef-client`
     command, which talks to a Chef Server. [GH-855]
   * **New provisioner:** `puppet-server` - Provision using Puppet by
@@ -19,17 +248,28 @@ IMPROVEMENTS:
       array configurations. [GH-950]
   * builder/amazon: Added `ssh_private_key_file` option [GH-971]
   * builder/amazon: Added `ami_virtualization_type` option [GH-1021]
+  * builder/digitalocean: Regions, image names, and sizes can be
+      names that are looked up for their valid ID. [GH-960]
   * builder/googlecompute: Configurable instance name. [GH-1065]
   * builder/openstack: Support for conventional OpenStack environmental
       variables such as `OS_USERNAME`, `OS_PASSWORD`, etc. [GH-768]
   * builder/openstack: Support `openstack_provider` option to automatically
       fill defaults for different OpenStack variants. [GH-912]
+  * builder/openstack: Support security groups. [GH-848]
   * builder/qemu: User variable expansion in `ssh_key_path` [GH-918]
+  * builder/qemu: Floppy disk files list can also include globs
+      and directories. [GH-1086]
   * builder/virtualbox: Support an `export_opts` option which allows
       specifying arbitrary arguments when exporting the VM. [GH-945]
+  * builder/virtualbox: Added `vboxmanage_post` option to run vboxmanage
+      commands just before exporting [GH-664]
+  * builder/virtualbox: Floppy disk files list can also include globs
+      and directories. [GH-1086]
   * builder/vmware: Workstation 10 support for Linux. [GH-900]
   * builder/vmware: add cloning support on Windows [GH-824]
-  * command/build: Added '-parallel' flag so you can disable parallelization
+  * builder/vmware: Floppy disk files list can also include globs
+      and directories. [GH-1086]
+  * command/build: Added `-parallel` flag so you can disable parallelization
     with `-no-parallel`. [GH-924]
   * post-processors/vsphere: `disk_mode` option. [GH-778]
   * provisioner/ansible: Add `inventory_file` option [GH-1006]
@@ -52,10 +292,13 @@ BUG FIXES:
       Windows [GH-963]
   * provisioner/ansible: set cwd to staging directory [GH-1016]
   * provisioners/chef-client: Don't chown directory with Ubuntu. [GH-939]
+  * provisioners/chef-solo: Deeply nested JSON works properly. [GH-1076]
   * provisioners/shell: Env var values can have equal signs. [GH-1045]
   * provisioners/shell: chmod the uploaded script file to 0777. [GH-994]
   * post-processor/docker-push: Allow repositories with ports. [GH-923]
   * post-processor/vagrant: Create parent directories for `output` path [GH-1059]
+  * post-processor/vsphere: datastore, network, and folder are no longer
+      required. [GH-1091]
 
 ## 0.5.2 (02/21/2014)
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index fe691d1f6..de8b8fb60 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,19 +56,32 @@ following steps in order to be able to compile and test Packer.
 1. Install Go. Make sure the Go version is at least Go 1.2. Packer will not work with anything less than
    Go 1.2. On a Mac, you can `brew install go` to install Go 1.2.
 
-2. Set and export the `GOPATH` environment variable. For example, you can
-   add `export GOPATH=$HOME/Documents/golang` to your `.bash_profile`.
+2. Set and export the `GOPATH` environment variable and update your `PATH`.
+   For example, you can add to your `.bash_profile`.
 
-3. Download the Packer source (and its dependencies) by running
+    ```
+    export GOPATH=$HOME/Documents/golang
+    export PATH=$PATH:$GOPATH/bin
+    ```
+
+3. Install and build `gox` with
+
+    ```
+    go get github.com/mitchellh/gox
+    cd $GOPATH/src/github.com/mitchellh/gox
+    go build
+    ```
+
+4. Download the Packer source (and its dependencies) by running
    `go get github.com/mitchellh/packer`. This will download the Packer
    source to `$GOPATH/src/github.com/mitchellh/packer`.
 
-4. Make your changes to the Packer source. You can run `make` from the main
+5. Make your changes to the Packer source. You can run `make` from the main
    source directory to recompile all the binaries. Any compilation errors
    will be shown when the binaries are rebuilding.
 
-5. Test your changes by running `make test` and then running
+6. Test your changes by running `make test` and then running
    `$GOPATH/src/github.com/mitchellh/packer/bin/packer` to build a machine.
 
-6. If everything works well and the tests pass, run `go fmt` on your code
+7. If everything works well and the tests pass, run `go fmt` on your code
    before submitting a pull request.
diff --git a/Makefile b/Makefile
index a39e8ee0e..f03b010f5 100644
--- a/Makefile
+++ b/Makefile
@@ -1,38 +1,20 @@
-NO_COLOR=\033[0m
-OK_COLOR=\033[32;01m
-ERROR_COLOR=\033[31;01m
-WARN_COLOR=\033[33;01m
-DEPS = $(go list -f '{{range .TestImports}}{{.}} {{end}}' ./...)
-UNAME := $(shell uname -s)
-ifeq ($(UNAME),Darwin)
-ECHO=echo
-else
-ECHO=/bin/echo -e
-endif
+TEST?=./...
 
-all: deps
-	@mkdir -p bin/
-	@$(ECHO) "$(OK_COLOR)==> Building$(NO_COLOR)"
-	@bash --norc -i ./scripts/devcompile.sh
+default: test
 
-deps:
-	@$(ECHO) "$(OK_COLOR)==> Installing dependencies$(NO_COLOR)"
-	@go get -d -v ./...
-	@echo $(DEPS) | xargs -n1 go get -d
+bin:
+	@sh -c "$(CURDIR)/scripts/build.sh"
+
+dev:
+	@TF_DEV=1 sh -c "$(CURDIR)/scripts/build.sh"
+
+test:
+	go test $(TEST) $(TESTARGS) -timeout=10s
+
+testrace:
+	go test -race $(TEST) $(TESTARGS)
 
 updatedeps:
-	@$(ECHO) "$(OK_COLOR)==> Updating all dependencies$(NO_COLOR)"
-	@go get -d -v -u ./...
-	@echo $(DEPS) | xargs -n1 go get -d -u
+	go get -d -v -p 2 ./...
 
-clean:
-	@rm -rf bin/ local/ pkg/ src/ website/.sass-cache website/build
-
-format:
-	go fmt ./...
-
-test: deps
-	@$(ECHO) "$(OK_COLOR)==> Testing Packer...$(NO_COLOR)"
-	go test ./...
-
-.PHONY: all clean deps format test updatedeps
+.PHONY: bin default test updatedeps
diff --git a/README.md b/README.md
index 721bdf586..6104e59d3 100644
--- a/README.md
+++ b/README.md
@@ -9,9 +9,18 @@ from a single source configuration.
 
 Packer is lightweight, runs on every major operating system, and is highly
 performant, creating machine images for multiple platforms in parallel.
-Packer comes out of the box with support for creating AMIs (EC2), VMware
-images, and VirtualBox images. Support for more platforms can be added via
-plugins.
+Packer comes out of the box with support for the following platforms:
+* Amazon EC2 (AMI). Both EBS-backed and instance-store AMIs
+* DigitalOcean
+* Docker
+* Google Compute Engine
+* OpenStack
+* Parallels
+* QEMU. Both KVM and Xen images.
+* VirtualBox
+* VMware
+
+Support for other platforms can be added via plugins.
 
 The images that Packer creates can easily be turned into
 [Vagrant](http://www.vagrantup.com) boxes.
@@ -69,40 +78,44 @@ http://www.packer.io/docs
 
 ## Developing Packer
 
-If you wish to work on Packer itself, you'll first need [Go](http://golang.org)
-installed (version 1.2+ is _required_). Make sure you have Go properly installed,
-including setting up your [GOPATH](http://golang.org/doc/code.html#GOPATH).
+If you wish to work on Packer itself or any of its built-in providers,
+you'll first need [Go](http://www.golang.org) installed (version 1.2+ is
+_required_). Make sure Go is properly installed, including setting up
+a [GOPATH](http://golang.org/doc/code.html#GOPATH).
 
-For some additional dependencies, Go needs [Mercurial](http://mercurial.selenic.com/)
-and [Bazaar](http://bazaar.canonical.com/en/) to be installed.
-Packer itself doesn't require these, but a dependency of a dependency does.
+Next, install the following software packages, which are needed for some dependencies:
 
-You'll also need [`gox`](https://github.com/mitchellh/gox)
-to compile packer. You can install that with:
+- [Bazaar](http://bazaar.canonical.com/en/)
+- [Git](http://git-scm.com/)
+- [Mercurial](http://mercurial.selenic.com/)
 
-```
-$ go get -u github.com/mitchellh/gox
-```
+Then, install [Gox](https://github.com/mitchellh/gox), which is used
+as a compilation tool on top of Go:
 
-Next, clone this repository into `$GOPATH/src/github.com/mitchellh/packer` and
-then just type `make`. In a few moments, you'll have a working `packer` executable:
+    $ go get -u github.com/mitchellh/gox
 
-```
-$ make
-...
-$ bin/packer
-...
-```
+Next, clone this repository into `$GOPATH/src/github.com/mitchellh/packer`.
+Install the necessary dependencies by running `make updatedeps` and then just
+type `make`. This will compile some more dependencies and then run the tests. If
+this exits with exit status 0, then everything is working!
 
-If you need to cross-compile Packer for other platforms, take a look at
-`scripts/dist.sh`.
+    $ make updatedeps
+    ...
+    $ make
+    ...
 
-You can run tests by typing `make test`.
+To compile a development version of Packer and the built-in plugins,
+run `make dev`. This will put Packer binaries in the `bin` folder:
 
-This will run tests for Packer core along with all the core builders and commands and such that come with Packer.
+    $ make dev
+    ...
+    $ bin/packer
+    ...
 
-If you make any changes to the code, run `make format` in order to automatically
-format the code according to Go standards.
 
-When new dependencies are added to packer you can use `make updatedeps` to
-get the latest and subsequently use `make` to compile and generate the `packer` binary.
+If you're developing a specific package, you can run tests for just that
+package by specifying the `TEST` variable. For example below, only
+`packer` package tests will be run.
+
+    $ make test TEST=./packer
+    ...
diff --git a/Vagrantfile b/Vagrantfile
new file mode 100644
index 000000000..8397a0fd6
--- /dev/null
+++ b/Vagrantfile
@@ -0,0 +1,45 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+$script = <<SCRIPT
+SRCROOT="/opt/go"
+
+# Install Go
+sudo apt-get update
+sudo apt-get install -y build-essential mercurial
+sudo hg clone -u release https://code.google.com/p/go ${SRCROOT}
+cd ${SRCROOT}/src
+sudo ./all.bash
+
+# Setup the GOPATH
+sudo mkdir -p /opt/gopath
+cat <<EOF >/tmp/gopath.sh
+export GOPATH="/opt/gopath"
+export PATH="/opt/go/bin:\$GOPATH/bin:\$PATH"
+EOF
+sudo mv /tmp/gopath.sh /etc/profile.d/gopath.sh
+sudo chmod 0755 /etc/profile.d/gopath.sh
+
+# Make sure the gopath is usable by vagrant
+sudo chown -R vagrant:vagrant $SRCROOT
+sudo chown -R vagrant:vagrant /opt/gopath
+
+# Install some other stuff we need
+sudo apt-get install -y curl git-core zip
+SCRIPT
+
+Vagrant.configure(2) do |config|
+  config.vm.box = "chef/ubuntu-12.04"
+
+  config.vm.provision "shell", inline: $script
+
+  config.vm.synced_folder ".", "/vagrant", disabled: true
+
+  ["vmware_fusion", "vmware_workstation"].each do |p|
+    config.vm.provider "p" do |v|
+      v.vmx["memsize"] = "2048"
+      v.vmx["numvcpus"] = "2"
+      v.vmx["cpuid.coresPerSocket"] = "1"
+    end
+  end
+end
diff --git a/builder/amazon/chroot/builder.go b/builder/amazon/chroot/builder.go
index 33c5bc586..832a26022 100644
--- a/builder/amazon/chroot/builder.go
+++ b/builder/amazon/chroot/builder.go
@@ -7,13 +7,14 @@ package chroot
 import (
 	"errors"
 	"fmt"
+	"log"
+	"runtime"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	awscommon "github.com/mitchellh/packer/builder/amazon/common"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"log"
-	"runtime"
 )
 
 // The unique ID for this builder
@@ -182,7 +183,11 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	// Build the steps
 	steps := []multistep.Step{
 		&StepInstanceInfo{},
-		&StepSourceAMIInfo{},
+		&awscommon.StepSourceAMIInfo{
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+		},
+		&StepCheckRootDevice{},
 		&StepFlock{},
 		&StepPrepareDevice{},
 		&StepCreateVolume{},
diff --git a/builder/amazon/chroot/communicator.go b/builder/amazon/chroot/communicator.go
index 22becd164..ae42ee49f 100644
--- a/builder/amazon/chroot/communicator.go
+++ b/builder/amazon/chroot/communicator.go
@@ -60,7 +60,7 @@ func (c *Communicator) Start(cmd *packer.RemoteCmd) error {
 	return nil
 }
 
-func (c *Communicator) Upload(dst string, r io.Reader) error {
+func (c *Communicator) Upload(dst string, r io.Reader, fi *os.FileInfo) error {
 	dst = filepath.Join(c.Chroot, dst)
 	log.Printf("Uploading to chroot dir: %s", dst)
 	tf, err := ioutil.TempFile("", "packer-amazon-chroot")
@@ -79,18 +79,27 @@ func (c *Communicator) Upload(dst string, r io.Reader) error {
 }
 
 func (c *Communicator) UploadDir(dst string, src string, exclude []string) error {
+	// If src ends with a trailing "/", copy from "src/." so that
+	// directory contents (including hidden files) are copied, but the
+	// directory "src" is omitted.  BSD does this automatically when
+	// the source contains a trailing slash, but linux does not.
+	if src[len(src)-1] == '/' {
+		src = src + "."
+	}
+
 	// TODO: remove any file copied if it appears in `exclude`
 	chrootDest := filepath.Join(c.Chroot, dst)
+
 	log.Printf("Uploading directory '%s' to '%s'", src, chrootDest)
-	cpCmd, err := c.CmdWrapper(fmt.Sprintf("cp -R %s* %s", src, chrootDest))
+	cpCmd, err := c.CmdWrapper(fmt.Sprintf("cp -R '%s' %s", src, chrootDest))
 	if err != nil {
 		return err
 	}
 
 	var stderr bytes.Buffer
 	cmd := ShellCommand(cpCmd)
-	cmd.Env = append(cmd.Env, os.Environ()...)
 	cmd.Env = append(cmd.Env, "LANG=C")
+	cmd.Env = append(cmd.Env, os.Environ()...)
 	cmd.Stderr = &stderr
 	err = cmd.Run()
 	if err == nil {
diff --git a/builder/amazon/chroot/device.go b/builder/amazon/chroot/device.go
index 77b7b444a..02a68433c 100644
--- a/builder/amazon/chroot/device.go
+++ b/builder/amazon/chroot/device.go
@@ -27,11 +27,12 @@ func AvailableDevice() (string, error) {
 			continue
 		}
 
-		for i := 1; i < 16; i++ {
-			device := fmt.Sprintf("/dev/%s%c%d", prefix, letter, i)
-			if _, err := os.Stat(device); err != nil {
-				return device, nil
-			}
+		// To be able to build both Paravirtual and HVM images, the unnumbered
+		// device and the first numbered one must be available.
+		// E.g. /dev/xvdf  and  /dev/xvdf1
+		numbered_device := fmt.Sprintf("%s%d", device, 1)
+		if _, err := os.Stat(numbered_device); err != nil {
+			return device, nil
 		}
 	}
 
diff --git a/builder/amazon/chroot/step_check_root_device.go b/builder/amazon/chroot/step_check_root_device.go
new file mode 100644
index 000000000..da18599aa
--- /dev/null
+++ b/builder/amazon/chroot/step_check_root_device.go
@@ -0,0 +1,31 @@
+package chroot
+
+import (
+	"fmt"
+
+	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+// StepCheckRootDevice makes sure the root device on the AMI is EBS-backed.
+type StepCheckRootDevice struct{}
+
+func (s *StepCheckRootDevice) Run(state multistep.StateBag) multistep.StepAction {
+	image := state.Get("source_image").(*ec2.Image)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Checking the root device on source AMI...")
+
+	// It must be EBS-backed otherwise the build won't work
+	if image.RootDeviceType != "ebs" {
+		err := fmt.Errorf("The root device of the source AMI must be EBS-backed.")
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepCheckRootDevice) Cleanup(multistep.StateBag) {}
diff --git a/builder/amazon/chroot/step_mount_device.go b/builder/amazon/chroot/step_mount_device.go
index a6419774f..3c3d959c1 100644
--- a/builder/amazon/chroot/step_mount_device.go
+++ b/builder/amazon/chroot/step_mount_device.go
@@ -3,6 +3,7 @@ package chroot
 import (
 	"bytes"
 	"fmt"
+	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 	"log"
@@ -26,6 +27,7 @@ type StepMountDevice struct {
 func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
+	image := state.Get("source_image").(*ec2.Image)
 	device := state.Get("device").(string)
 	wrappedCommand := state.Get("wrappedCommand").(CommandWrapper)
 
@@ -57,10 +59,17 @@ func (s *StepMountDevice) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
+	log.Printf("Source image virtualization type is: %s", image.VirtualizationType)
+	deviceMount := device
+	if image.VirtualizationType == "hvm" {
+		deviceMount = fmt.Sprintf("%s%d", device, 1)
+	}
+	state.Put("deviceMount", deviceMount)
+
 	ui.Say("Mounting the root device...")
 	stderr := new(bytes.Buffer)
 	mountCommand, err := wrappedCommand(
-		fmt.Sprintf("mount %s %s", device, mountPath))
+		fmt.Sprintf("mount %s %s", deviceMount, mountPath))
 	if err != nil {
 		err := fmt.Errorf("Error creating mount command: %s", err)
 		state.Put("error", err)
diff --git a/builder/amazon/chroot/step_register_ami.go b/builder/amazon/chroot/step_register_ami.go
index 173d88d6d..62e6a3ff0 100644
--- a/builder/amazon/chroot/step_register_ami.go
+++ b/builder/amazon/chroot/step_register_ami.go
@@ -2,6 +2,7 @@ package chroot
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	awscommon "github.com/mitchellh/packer/builder/amazon/common"
@@ -29,13 +30,11 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 		blockDevices[i] = newDevice
 	}
 
-	registerOpts := &ec2.RegisterImage{
-		Name:           config.AMIName,
-		Architecture:   image.Architecture,
-		KernelId:       image.KernelId,
-		RamdiskId:      image.RamdiskId,
-		RootDeviceName: image.RootDeviceName,
-		BlockDevices:   blockDevices,
+	registerOpts := buildRegisterOpts(config, image, blockDevices)
+
+	// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
+	if config.AMIEnhancedNetworking {
+		registerOpts.SriovNetSupport = "simple"
 	}
 
 	registerResp, err := ec2conn.RegisterImage(registerOpts)
@@ -71,3 +70,20 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 }
 
 func (s *StepRegisterAMI) Cleanup(state multistep.StateBag) {}
+
+func buildRegisterOpts(config *Config, image *ec2.Image, blockDevices []ec2.BlockDeviceMapping) *ec2.RegisterImage {
+	registerOpts := &ec2.RegisterImage{
+		Name:           config.AMIName,
+		Architecture:   image.Architecture,
+		RootDeviceName: image.RootDeviceName,
+		BlockDevices:   blockDevices,
+		VirtType:       config.AMIVirtType,
+	}
+
+	if config.AMIVirtType != "hvm" {
+		registerOpts.KernelId = image.KernelId
+		registerOpts.RamdiskId = image.RamdiskId
+	}
+
+	return registerOpts
+}
diff --git a/builder/amazon/chroot/step_register_ami_test.go b/builder/amazon/chroot/step_register_ami_test.go
new file mode 100644
index 000000000..393b95c8b
--- /dev/null
+++ b/builder/amazon/chroot/step_register_ami_test.go
@@ -0,0 +1,73 @@
+package chroot
+
+import (
+	"github.com/mitchellh/goamz/ec2"
+	"testing"
+)
+
+func testImage() ec2.Image {
+	return ec2.Image{
+		Id:           "ami-abcd1234",
+		Name:         "ami_test_name",
+		Architecture: "x86_64",
+		KernelId:     "aki-abcd1234",
+	}
+}
+
+func TestStepRegisterAmi_buildRegisterOpts_pv(t *testing.T) {
+	config := Config{}
+	config.AMIName = "test_ami_name"
+	config.AMIDescription = "test_ami_description"
+	config.AMIVirtType = "paravirtual"
+
+	image := testImage()
+
+	blockDevices := []ec2.BlockDeviceMapping{}
+
+	opts := buildRegisterOpts(&config, &image, blockDevices)
+
+	expected := config.AMIVirtType
+	if opts.VirtType != expected {
+		t.Fatalf("Unexpected VirtType value: expected %s got %s\n", expected, opts.VirtType)
+	}
+
+	expected = config.AMIName
+	if opts.Name != expected {
+		t.Fatalf("Unexpected Name value: expected %s got %s\n", expected, opts.Name)
+	}
+
+	expected = image.KernelId
+	if opts.KernelId != expected {
+		t.Fatalf("Unexpected KernelId value: expected %s got %s\n", expected, opts.KernelId)
+	}
+
+}
+
+func TestStepRegisterAmi_buildRegisterOpts_hvm(t *testing.T) {
+	config := Config{}
+	config.AMIName = "test_ami_name"
+	config.AMIDescription = "test_ami_description"
+	config.AMIVirtType = "hvm"
+
+	image := testImage()
+
+	blockDevices := []ec2.BlockDeviceMapping{}
+
+	opts := buildRegisterOpts(&config, &image, blockDevices)
+
+	expected := config.AMIVirtType
+	if opts.VirtType != expected {
+		t.Fatalf("Unexpected VirtType value: expected %s got %s\n", expected, opts.VirtType)
+	}
+
+	expected = config.AMIName
+	if opts.Name != expected {
+		t.Fatalf("Unexpected Name value: expected %s got %s\n", expected, opts.Name)
+	}
+
+	expected = ""
+	if opts.KernelId != expected {
+		t.Fatalf("Unexpected KernelId value: expected %s got %s\n", expected, opts.KernelId)
+	}
+
+}
diff --git a/builder/amazon/chroot/step_snapshot.go b/builder/amazon/chroot/step_snapshot.go
index cadf65f52..cad4b782b 100644
--- a/builder/amazon/chroot/step_snapshot.go
+++ b/builder/amazon/chroot/step_snapshot.go
@@ -3,6 +3,8 @@ package chroot
 import (
 	"errors"
 	"fmt"
+	"time"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	awscommon "github.com/mitchellh/packer/builder/amazon/common"
@@ -23,7 +25,9 @@ func (s *StepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 	volumeId := state.Get("volume_id").(string)
 
 	ui.Say("Creating snapshot...")
-	createSnapResp, err := ec2conn.CreateSnapshot(volumeId, "")
+	createSnapResp, err := ec2conn.CreateSnapshot(
+		volumeId,
+		fmt.Sprintf("Packer: %s", time.Now().String()))
 	if err != nil {
 		err := fmt.Errorf("Error creating snapshot: %s", err)
 		state.Put("error", err)
diff --git a/builder/amazon/common/access_config.go b/builder/amazon/common/access_config.go
index 1690869d0..a9a60d7cf 100644
--- a/builder/amazon/common/access_config.go
+++ b/builder/amazon/common/access_config.go
@@ -13,6 +13,7 @@ type AccessConfig struct {
 	AccessKey string `mapstructure:"access_key"`
 	SecretKey string `mapstructure:"secret_key"`
 	RawRegion string `mapstructure:"region"`
+	Token     string `mapstructure:"token"`
 }
 
 // Auth returns a valid aws.Auth object for access to AWS services, or
@@ -23,6 +24,10 @@ func (c *AccessConfig) Auth() (aws.Auth, error) {
 		// Store the accesskey and secret that we got...
 		c.AccessKey = auth.AccessKey
 		c.SecretKey = auth.SecretKey
+		c.Token = auth.Token
+	}
+	if c.Token != "" {
+		auth.Token = c.Token
 	}
 
 	return auth, err
diff --git a/builder/amazon/common/ami_config.go b/builder/amazon/common/ami_config.go
index 53ef7f8e2..91c2d12d0 100644
--- a/builder/amazon/common/ami_config.go
+++ b/builder/amazon/common/ami_config.go
@@ -2,20 +2,22 @@ package common
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/goamz/aws"
 	"github.com/mitchellh/packer/packer"
 )
 
 // AMIConfig is for common configuration related to creating AMIs.
 type AMIConfig struct {
-	AMIName         string            `mapstructure:"ami_name"`
-	AMIDescription  string            `mapstructure:"ami_description"`
-	AMIVirtType     string            `mapstructure:"ami_virtualization_type"`
-	AMIUsers        []string          `mapstructure:"ami_users"`
-	AMIGroups       []string          `mapstructure:"ami_groups"`
-	AMIProductCodes []string          `mapstructure:"ami_product_codes"`
-	AMIRegions      []string          `mapstructure:"ami_regions"`
-	AMITags         map[string]string `mapstructure:"tags"`
+	AMIName               string            `mapstructure:"ami_name"`
+	AMIDescription        string            `mapstructure:"ami_description"`
+	AMIVirtType           string            `mapstructure:"ami_virtualization_type"`
+	AMIUsers              []string          `mapstructure:"ami_users"`
+	AMIGroups             []string          `mapstructure:"ami_groups"`
+	AMIProductCodes       []string          `mapstructure:"ami_product_codes"`
+	AMIRegions            []string          `mapstructure:"ami_regions"`
+	AMITags               map[string]string `mapstructure:"tags"`
+	AMIEnhancedNetworking bool              `mapstructure:"enhanced_networking"`
 }
 
 func (c *AMIConfig) Prepare(t *packer.ConfigTemplate) []error {
diff --git a/builder/amazon/common/artifact.go b/builder/amazon/common/artifact.go
index 3913833d7..8831d313b 100644
--- a/builder/amazon/common/artifact.go
+++ b/builder/amazon/common/artifact.go
@@ -6,6 +6,7 @@ import (
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/packer/packer"
 	"log"
+	"sort"
 	"strings"
 )
 
@@ -36,6 +37,7 @@ func (a *Artifact) Id() string {
 		parts = append(parts, fmt.Sprintf("%s:%s", region, amiId))
 	}
 
+	sort.Strings(parts)
 	return strings.Join(parts, ",")
 }
 
@@ -46,9 +48,14 @@ func (a *Artifact) String() string {
 		amiStrings = append(amiStrings, single)
 	}
 
+	sort.Strings(amiStrings)
 	return fmt.Sprintf("AMIs were created:\n\n%s", strings.Join(amiStrings, "\n"))
 }
 
+func (a *Artifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *Artifact) Destroy() error {
 	errors := make([]error, 0)
 
diff --git a/builder/amazon/common/block_device.go b/builder/amazon/common/block_device.go
index 08f07e269..dc87c07fb 100644
--- a/builder/amazon/common/block_device.go
+++ b/builder/amazon/common/block_device.go
@@ -1,19 +1,23 @@
 package common
 
 import (
+	"fmt"
+
 	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/packer/packer"
 )
 
 // BlockDevice
 type BlockDevice struct {
-	DeviceName          string `mapstructure:"device_name"`
-	VirtualName         string `mapstructure:"virtual_name"`
-	SnapshotId          string `mapstructure:"snapshot_id"`
-	VolumeType          string `mapstructure:"volume_type"`
-	VolumeSize          int64  `mapstructure:"volume_size"`
 	DeleteOnTermination bool   `mapstructure:"delete_on_termination"`
+	DeviceName          string `mapstructure:"device_name"`
+	Encrypted           bool   `mapstructure:"encrypted"`
 	IOPS                int64  `mapstructure:"iops"`
 	NoDevice            bool   `mapstructure:"no_device"`
+	SnapshotId          string `mapstructure:"snapshot_id"`
+	VirtualName         string `mapstructure:"virtual_name"`
+	VolumeType          string `mapstructure:"volume_type"`
+	VolumeSize          int64  `mapstructure:"volume_size"`
 }
 
 type BlockDevices struct {
@@ -34,11 +38,57 @@ func buildBlockDevices(b []BlockDevice) []ec2.BlockDeviceMapping {
 			DeleteOnTermination: blockDevice.DeleteOnTermination,
 			IOPS:                blockDevice.IOPS,
 			NoDevice:            blockDevice.NoDevice,
+			Encrypted:           blockDevice.Encrypted,
 		})
 	}
 	return blockDevices
 }
 
+func (b *BlockDevices) Prepare(t *packer.ConfigTemplate) []error {
+	if t == nil {
+		var err error
+		t, err = packer.NewConfigTemplate()
+		if err != nil {
+			return []error{err}
+		}
+	}
+
+	lists := map[string][]BlockDevice{
+		"ami_block_device_mappings":    b.AMIMappings,
+		"launch_block_device_mappings": b.LaunchMappings,
+	}
+
+	var errs []error
+	for outer, bds := range lists {
+		for i, bd := range bds {
+			templates := map[string]*string{
+				"device_name":  &bd.DeviceName,
+				"snapshot_id":  &bd.SnapshotId,
+				"virtual_name": &bd.VirtualName,
+				"volume_type":  &bd.VolumeType,
+			}
+
+			errs := make([]error, 0)
+			for n, ptr := range templates {
+				var err error
+				*ptr, err = t.Process(*ptr, nil)
+				if err != nil {
+					errs = append(
+						errs, fmt.Errorf(
+							"Error processing %s[%d].%s: %s",
+							outer, i, n, err))
+				}
+			}
+		}
+	}
+
+	if len(errs) > 0 {
+		return errs
+	}
+
+	return nil
+}
+
 func (b *BlockDevices) BuildAMIDevices() []ec2.BlockDeviceMapping {
 	return buildBlockDevices(b.AMIMappings)
 }
diff --git a/builder/amazon/common/block_device_test.go b/builder/amazon/common/block_device_test.go
index 2e671e3d6..838b23aec 100644
--- a/builder/amazon/common/block_device_test.go
+++ b/builder/amazon/common/block_device_test.go
@@ -7,38 +7,47 @@ import (
 )
 
 func TestBlockDevice(t *testing.T) {
-	ec2Mapping := []ec2.BlockDeviceMapping{
-		ec2.BlockDeviceMapping{
-			DeviceName:          "/dev/sdb",
-			VirtualName:         "ephemeral0",
-			SnapshotId:          "snap-1234",
-			VolumeType:          "standard",
-			VolumeSize:          8,
-			DeleteOnTermination: true,
-			IOPS:                1000,
+	cases := []struct {
+		Config *BlockDevice
+		Result *ec2.BlockDeviceMapping
+	}{
+		{
+			Config: &BlockDevice{
+				DeviceName:          "/dev/sdb",
+				VirtualName:         "ephemeral0",
+				SnapshotId:          "snap-1234",
+				VolumeType:          "standard",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+				IOPS:                1000,
+			},
+
+			Result: &ec2.BlockDeviceMapping{
+				DeviceName:          "/dev/sdb",
+				VirtualName:         "ephemeral0",
+				SnapshotId:          "snap-1234",
+				VolumeType:          "standard",
+				VolumeSize:          8,
+				DeleteOnTermination: true,
+				IOPS:                1000,
+			},
 		},
 	}
 
-	blockDevice := BlockDevice{
-		DeviceName:          "/dev/sdb",
-		VirtualName:         "ephemeral0",
-		SnapshotId:          "snap-1234",
-		VolumeType:          "standard",
-		VolumeSize:          8,
-		DeleteOnTermination: true,
-		IOPS:                1000,
-	}
+	for _, tc := range cases {
+		blockDevices := BlockDevices{
+			AMIMappings:    []BlockDevice{*tc.Config},
+			LaunchMappings: []BlockDevice{*tc.Config},
+		}
 
-	blockDevices := BlockDevices{
-		AMIMappings:    []BlockDevice{blockDevice},
-		LaunchMappings: []BlockDevice{blockDevice},
-	}
+		expected := []ec2.BlockDeviceMapping{*tc.Result}
 
-	if !reflect.DeepEqual(ec2Mapping, blockDevices.BuildAMIDevices()) {
-		t.Fatalf("bad: %#v", ec2Mapping)
-	}
+		if !reflect.DeepEqual(expected, blockDevices.BuildAMIDevices()) {
+			t.Fatalf("bad: %#v", expected)
+		}
 
-	if !reflect.DeepEqual(ec2Mapping, blockDevices.BuildLaunchDevices()) {
-		t.Fatalf("bad: %#v", ec2Mapping)
+		if !reflect.DeepEqual(expected, blockDevices.BuildLaunchDevices()) {
+			t.Fatalf("bad: %#v", expected)
+		}
 	}
 }
diff --git a/builder/amazon/common/run_config.go b/builder/amazon/common/run_config.go
index c50c22f7e..a71387623 100644
--- a/builder/amazon/common/run_config.go
+++ b/builder/amazon/common/run_config.go
@@ -3,9 +3,11 @@ package common
 import (
 	"errors"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
 	"os"
 	"time"
+
+	"github.com/mitchellh/packer/common/uuid"
+	"github.com/mitchellh/packer/packer"
 )
 
 // RunConfig contains configuration for running an instance from a source
@@ -17,9 +19,12 @@ type RunConfig struct {
 	InstanceType             string            `mapstructure:"instance_type"`
 	RunTags                  map[string]string `mapstructure:"run_tags"`
 	SourceAmi                string            `mapstructure:"source_ami"`
+	SpotPrice                string            `mapstructure:"spot_price"`
+	SpotPriceAutoProduct     string            `mapstructure:"spot_price_auto_product"`
 	RawSSHTimeout            string            `mapstructure:"ssh_timeout"`
 	SSHUsername              string            `mapstructure:"ssh_username"`
 	SSHPrivateKeyFile        string            `mapstructure:"ssh_private_key_file"`
+	SSHPrivateIp             bool              `mapstructure:"ssh_private_ip"`
 	SSHPort                  int               `mapstructure:"ssh_port"`
 	SecurityGroupId          string            `mapstructure:"security_group_id"`
 	SecurityGroupIds         []string          `mapstructure:"security_group_ids"`
@@ -42,6 +47,34 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		}
 	}
 
+	templates := map[string]*string{
+		"iam_instance_profile":    &c.IamInstanceProfile,
+		"instance_type":           &c.InstanceType,
+		"spot_price":              &c.SpotPrice,
+		"spot_price_auto_product": &c.SpotPriceAutoProduct,
+		"ssh_timeout":             &c.RawSSHTimeout,
+		"ssh_username":            &c.SSHUsername,
+		"ssh_private_key_file":    &c.SSHPrivateKeyFile,
+		"source_ami":              &c.SourceAmi,
+		"subnet_id":               &c.SubnetId,
+		"temporary_key_pair_name": &c.TemporaryKeyPairName,
+		"vpc_id":                  &c.VpcId,
+		"availability_zone":       &c.AvailabilityZone,
+		"user_data":               &c.UserData,
+		"user_data_file":          &c.UserDataFile,
+		"security_group_id":       &c.SecurityGroupId,
+	}
+
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(
+				errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
 	// Defaults
 	if c.SSHPort == 0 {
 		c.SSHPort = 22
@@ -52,12 +85,12 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 	}
 
 	if c.TemporaryKeyPairName == "" {
-		c.TemporaryKeyPairName = "packer {{uuid}}"
+		c.TemporaryKeyPairName = fmt.Sprintf(
+			"packer %s", uuid.TimeOrderedUUID())
 	}
 
 	// Validation
 	var err error
-	errs := make([]error, 0)
 	if c.SourceAmi == "" {
 		errs = append(errs, errors.New("A source_ami must be specified"))
 	}
@@ -66,6 +99,13 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		errs = append(errs, errors.New("An instance_type must be specified"))
 	}
 
+	if c.SpotPrice == "auto" {
+		if c.SpotPriceAutoProduct == "" {
+			errs = append(errs, errors.New(
+				"spot_price_auto_product must be specified when spot_price is auto"))
+		}
+	}
+
 	if c.SSHUsername == "" {
 		errs = append(errs, errors.New("An ssh_username must be specified"))
 	}
@@ -87,28 +127,6 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		}
 	}
 
-	templates := map[string]*string{
-		"iam_instance_profile":    &c.IamInstanceProfile,
-		"instance_type":           &c.InstanceType,
-		"ssh_timeout":             &c.RawSSHTimeout,
-		"ssh_username":            &c.SSHUsername,
-		"ssh_private_key_file":    &c.SSHPrivateKeyFile,
-		"source_ami":              &c.SourceAmi,
-		"subnet_id":               &c.SubnetId,
-		"temporary_key_pair_name": &c.TemporaryKeyPairName,
-		"vpc_id":                  &c.VpcId,
-		"availability_zone":       &c.AvailabilityZone,
-	}
-
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = t.Process(*ptr, nil)
-		if err != nil {
-			errs = append(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
 	sliceTemplates := map[string][]string{
 		"security_group_ids": c.SecurityGroupIds,
 	}
diff --git a/builder/amazon/common/run_config_test.go b/builder/amazon/common/run_config_test.go
index 1d376b1dd..8e9c4b6b9 100644
--- a/builder/amazon/common/run_config_test.go
+++ b/builder/amazon/common/run_config_test.go
@@ -47,6 +47,19 @@ func TestRunConfigPrepare_SourceAmi(t *testing.T) {
 	}
 }
 
+func TestRunConfigPrepare_SpotAuto(t *testing.T) {
+	c := testConfig()
+	c.SpotPrice = "auto"
+	if err := c.Prepare(nil); len(err) != 1 {
+		t.Fatalf("err: %s", err)
+	}
+
+	c.SpotPriceAutoProduct = "foo"
+	if err := c.Prepare(nil); len(err) != 0 {
+		t.Fatalf("err: %s", err)
+	}
+}
+
 func TestRunConfigPrepare_SSHPort(t *testing.T) {
 	c := testConfig()
 	c.SSHPort = 0
diff --git a/builder/amazon/common/ssh.go b/builder/amazon/common/ssh.go
index 88a3dafbd..34fd746cb 100644
--- a/builder/amazon/common/ssh.go
+++ b/builder/amazon/common/ssh.go
@@ -11,7 +11,7 @@ import (
 
 // SSHAddress returns a function that can be given to the SSH communicator
 // for determining the SSH address based on the instance DNS name.
-func SSHAddress(e *ec2.EC2, port int) func(multistep.StateBag) (string, error) {
+func SSHAddress(e *ec2.EC2, port int, private bool) func(multistep.StateBag) (string, error) {
 	return func(state multistep.StateBag) (string, error) {
 		for j := 0; j < 2; j++ {
 			var host string
@@ -19,7 +19,7 @@ func SSHAddress(e *ec2.EC2, port int) func(multistep.StateBag) (string, error) {
 			if i.DNSName != "" {
 				host = i.DNSName
 			} else if i.VpcId != "" {
-				if i.PublicIpAddress != "" {
+				if i.PublicIpAddress != "" && !private {
 					host = i.PublicIpAddress
 				} else {
 					host = i.PrivateIpAddress
diff --git a/builder/amazon/common/state.go b/builder/amazon/common/state.go
index 688a918a5..62e861d74 100644
--- a/builder/amazon/common/state.go
+++ b/builder/amazon/common/state.go
@@ -6,6 +6,9 @@ import (
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	"log"
+	"net"
+	"os"
+	"strconv"
 	"time"
 )
 
@@ -38,6 +41,9 @@ func AMIStateRefreshFunc(conn *ec2.EC2, imageId string) StateRefreshFunc {
 			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidAMIID.NotFound" {
 				// Set this to nil as if we didn't find anything.
 				resp = nil
+			} else if isTransientNetworkError(err) {
+				// Transient network error, treat it as if we didn't find anything
+				resp = nil
 			} else {
 				log.Printf("Error on AMIStateRefresh: %s", err)
 				return nil, "", err
@@ -64,6 +70,9 @@ func InstanceStateRefreshFunc(conn *ec2.EC2, i *ec2.Instance) StateRefreshFunc {
 			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidInstanceID.NotFound" {
 				// Set this to nil as if we didn't find anything.
 				resp = nil
+			} else if isTransientNetworkError(err) {
+				// Transient network error, treat it as if we didn't find anything
+				resp = nil
 			} else {
 				log.Printf("Error on InstanceStateRefresh: %s", err)
 				return nil, "", err
@@ -81,11 +90,42 @@ func InstanceStateRefreshFunc(conn *ec2.EC2, i *ec2.Instance) StateRefreshFunc {
 	}
 }
 
+// SpotRequestStateRefreshFunc returns a StateRefreshFunc that is used to watch
+// a spot request for state changes.
+func SpotRequestStateRefreshFunc(conn *ec2.EC2, spotRequestId string) StateRefreshFunc {
+	return func() (interface{}, string, error) {
+		resp, err := conn.DescribeSpotRequests([]string{spotRequestId}, ec2.NewFilter())
+		if err != nil {
+			if ec2err, ok := err.(*ec2.Error); ok && ec2err.Code == "InvalidSpotInstanceRequestID.NotFound" {
+				// Set this to nil as if we didn't find anything.
+				resp = nil
+			} else if isTransientNetworkError(err) {
+				// Transient network error, treat it as if we didn't find anything
+				resp = nil
+			} else {
+				log.Printf("Error on SpotRequestStateRefresh: %s", err)
+				return nil, "", err
+			}
+		}
+
+		if resp == nil || len(resp.SpotRequestResults) == 0 {
+			// Sometimes AWS has consistency issues and doesn't see the
+			// SpotRequest. Return an empty state.
+			return nil, "", nil
+		}
+
+		i := resp.SpotRequestResults[0]
+		return i, i.State, nil
+	}
+}
+
 // WaitForState watches an object and waits for it to achieve a certain
 // state.
 func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 	log.Printf("Waiting for state to become: %s", conf.Target)
 
+	sleepSeconds := 2
+	maxTicks := int(TimeoutSeconds()/sleepSeconds) + 1
 	notfoundTick := 0
 
 	for {
@@ -99,7 +139,7 @@ func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 			// If we didn't find the resource, check if we have been
 			// not finding it for awhile, and if so, report an error.
 			notfoundTick += 1
-			if notfoundTick > 20 {
+			if notfoundTick > maxTicks {
 				return nil, errors.New("couldn't find resource")
 			}
 		} else {
@@ -125,13 +165,41 @@ func WaitForState(conf *StateChangeConf) (i interface{}, err error) {
 			}
 
 			if !found {
-				fmt.Errorf("unexpected state '%s', wanted target '%s'", currentState, conf.Target)
-				return
+				err := fmt.Errorf("unexpected state '%s', wanted target '%s'", currentState, conf.Target)
+				return nil, err
 			}
 		}
 
-		time.Sleep(2 * time.Second)
+		time.Sleep(time.Duration(sleepSeconds) * time.Second)
 	}
 
 	return
 }
+
+func isTransientNetworkError(err error) bool {
+	if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
+		return true
+	}
+
+	return false
+}
+
+// Returns 300 seconds (5 minutes) by default
+// Some AWS operations, like copying an AMI to a distant region, take a very long time
+// Allow user to override with AWS_TIMEOUT_SECONDS environment variable
+func TimeoutSeconds() (seconds int) {
+	seconds = 300
+
+	override := os.Getenv("AWS_TIMEOUT_SECONDS")
+	if override != "" {
+		n, err := strconv.Atoi(override)
+		if err != nil {
+			log.Printf("Invalid timeout seconds '%s', using default", override)
+		} else {
+			seconds = n
+		}
+	}
+
+	log.Printf("Allowing %ds to complete (change with AWS_TIMEOUT_SECONDS)", seconds)
+	return seconds
+}
diff --git a/builder/amazon/common/step_run_source_instance.go b/builder/amazon/common/step_run_source_instance.go
index c9827e589..50cedf6ea 100644
--- a/builder/amazon/common/step_run_source_instance.go
+++ b/builder/amazon/common/step_run_source_instance.go
@@ -2,10 +2,14 @@ package common
 
 import (
 	"fmt"
+	"io/ioutil"
+	"log"
+	"strconv"
+	"time"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"io/ioutil"
 )
 
 type StepRunSourceInstance struct {
@@ -17,12 +21,15 @@ type StepRunSourceInstance struct {
 	InstanceType             string
 	IamInstanceProfile       string
 	SourceAMI                string
+	SpotPrice                string
+	SpotPriceProduct         string
 	SubnetId                 string
 	Tags                     map[string]string
 	UserData                 string
 	UserDataFile             string
 
-	instance *ec2.Instance
+	instance    *ec2.Instance
+	spotRequest *ec2.SpotRequestResult
 }
 
 func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepAction {
@@ -47,21 +54,6 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		securityGroups[n] = ec2.SecurityGroup{Id: securityGroupId}
 	}
 
-	runOpts := &ec2.RunInstances{
-		KeyName:                  keyName,
-		ImageId:                  s.SourceAMI,
-		InstanceType:             s.InstanceType,
-		UserData:                 []byte(userData),
-		MinCount:                 0,
-		MaxCount:                 0,
-		SecurityGroups:           securityGroups,
-		IamInstanceProfile:       s.IamInstanceProfile,
-		SubnetId:                 s.SubnetId,
-		AssociatePublicIpAddress: s.AssociatePublicIpAddress,
-		BlockDevices:             s.BlockDevices.BuildLaunchDevices(),
-		AvailZone:                s.AvailabilityZone,
-	}
-
 	ui.Say("Launching a source AWS instance...")
 	imageResp, err := ec2conn.Images([]string{s.SourceAMI}, ec2.NewFilter())
 	if err != nil {
@@ -82,29 +74,137 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 		return multistep.ActionHalt
 	}
 
-	runResp, err := ec2conn.RunInstances(runOpts)
+	spotPrice := s.SpotPrice
+	if spotPrice == "auto" {
+		ui.Message(fmt.Sprintf(
+			"Finding spot price for %s %s...",
+			s.SpotPriceProduct, s.InstanceType))
+
+		// Detect the spot price
+		startTime := time.Now().Add(-1 * time.Hour)
+		resp, err := ec2conn.DescribeSpotPriceHistory(&ec2.DescribeSpotPriceHistory{
+			InstanceType:       []string{s.InstanceType},
+			ProductDescription: []string{s.SpotPriceProduct},
+			AvailabilityZone:   s.AvailabilityZone,
+			StartTime:          startTime,
+		})
+		if err != nil {
+			err := fmt.Errorf("Error finding spot price: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		var price float64
+		for _, history := range resp.History {
+			log.Printf("[INFO] Candidate spot price: %s", history.SpotPrice)
+			current, err := strconv.ParseFloat(history.SpotPrice, 64)
+			if err != nil {
+				log.Printf("[ERR] Error parsing spot price: %s", err)
+				continue
+			}
+			if price == 0 || current < price {
+				price = current
+			}
+		}
+		if price == 0 {
+			err := fmt.Errorf("No candidate spot prices found!")
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		spotPrice = strconv.FormatFloat(price, 'f', -1, 64)
+	}
+
+	var instanceId string
+
+	if spotPrice == "" {
+		runOpts := &ec2.RunInstances{
+			KeyName:                  keyName,
+			ImageId:                  s.SourceAMI,
+			InstanceType:             s.InstanceType,
+			UserData:                 []byte(userData),
+			MinCount:                 0,
+			MaxCount:                 0,
+			SecurityGroups:           securityGroups,
+			IamInstanceProfile:       s.IamInstanceProfile,
+			SubnetId:                 s.SubnetId,
+			AssociatePublicIpAddress: s.AssociatePublicIpAddress,
+			BlockDevices:             s.BlockDevices.BuildLaunchDevices(),
+			AvailZone:                s.AvailabilityZone,
+		}
+		runResp, err := ec2conn.RunInstances(runOpts)
+		if err != nil {
+			err := fmt.Errorf("Error launching source instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceId = runResp.Instances[0].InstanceId
+	} else {
+		ui.Message(fmt.Sprintf(
+			"Requesting spot instance '%s' for: %s",
+			s.InstanceType, spotPrice))
+
+		runOpts := &ec2.RequestSpotInstances{
+			SpotPrice:                spotPrice,
+			KeyName:                  keyName,
+			ImageId:                  s.SourceAMI,
+			InstanceType:             s.InstanceType,
+			UserData:                 []byte(userData),
+			SecurityGroups:           securityGroups,
+			IamInstanceProfile:       s.IamInstanceProfile,
+			SubnetId:                 s.SubnetId,
+			AssociatePublicIpAddress: s.AssociatePublicIpAddress,
+			BlockDevices:             s.BlockDevices.BuildLaunchDevices(),
+			AvailZone:                s.AvailabilityZone,
+		}
+		runSpotResp, err := ec2conn.RequestSpotInstances(runOpts)
+		if err != nil {
+			err := fmt.Errorf("Error launching source spot instance: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		s.spotRequest = &runSpotResp.SpotRequestResults[0]
+
+		spotRequestId := s.spotRequest.SpotRequestId
+		ui.Message(fmt.Sprintf("Waiting for spot request (%s) to become active...", spotRequestId))
+		stateChange := StateChangeConf{
+			Pending:   []string{"open"},
+			Target:    "active",
+			Refresh:   SpotRequestStateRefreshFunc(ec2conn, spotRequestId),
+			StepState: state,
+		}
+		_, err = WaitForState(&stateChange)
+		if err != nil {
+			err := fmt.Errorf("Error waiting for spot request (%s) to become ready: %s", spotRequestId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		spotResp, err := ec2conn.DescribeSpotRequests([]string{spotRequestId}, nil)
+		if err != nil {
+			err := fmt.Errorf("Error finding spot request (%s): %s", spotRequestId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceId = spotResp.SpotRequestResults[0].InstanceId
+	}
+
+	instanceResp, err := ec2conn.Instances([]string{instanceId}, nil)
 	if err != nil {
-		err := fmt.Errorf("Error launching source instance: %s", err)
+		err := fmt.Errorf("Error finding source instance (%s): %s", instanceId, err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
 	}
-
-	s.instance = &runResp.Instances[0]
+	s.instance = &instanceResp.Reservations[0].Instances[0]
 	ui.Message(fmt.Sprintf("Instance ID: %s", s.instance.InstanceId))
 
-	ec2Tags := make([]ec2.Tag, 1, len(s.Tags)+1)
-	ec2Tags[0] = ec2.Tag{"Name", "Packer Builder"}
-	for k, v := range s.Tags {
-		ec2Tags = append(ec2Tags, ec2.Tag{k, v})
-	}
-
-	_, err = ec2conn.CreateTags([]string{s.instance.InstanceId}, ec2Tags)
-	if err != nil {
-		ui.Message(
-			fmt.Sprintf("Failed to tag a Name on the builder instance: %s", err))
-	}
-
 	ui.Say(fmt.Sprintf("Waiting for instance (%s) to become ready...", s.instance.InstanceId))
 	stateChange := StateChangeConf{
 		Pending:   []string{"pending"},
@@ -122,6 +222,18 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 
 	s.instance = latestInstance.(*ec2.Instance)
 
+	ec2Tags := make([]ec2.Tag, 1, len(s.Tags)+1)
+	ec2Tags[0] = ec2.Tag{"Name", "Packer Builder"}
+	for k, v := range s.Tags {
+		ec2Tags = append(ec2Tags, ec2.Tag{k, v})
+	}
+
+	_, err = ec2conn.CreateTags([]string{s.instance.InstanceId}, ec2Tags)
+	if err != nil {
+		ui.Message(
+			fmt.Sprintf("Failed to tag a Name on the builder instance: %s", err))
+	}
+
 	if s.Debug {
 		if s.instance.DNSName != "" {
 			ui.Message(fmt.Sprintf("Public DNS: %s", s.instance.DNSName))
@@ -142,24 +254,41 @@ func (s *StepRunSourceInstance) Run(state multistep.StateBag) multistep.StepActi
 }
 
 func (s *StepRunSourceInstance) Cleanup(state multistep.StateBag) {
-	if s.instance == nil {
-		return
-	}
 
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say("Terminating the source AWS instance...")
-	if _, err := ec2conn.TerminateInstances([]string{s.instance.InstanceId}); err != nil {
-		ui.Error(fmt.Sprintf("Error terminating instance, may still be around: %s", err))
-		return
+	// Cancel the spot request if it exists
+	if s.spotRequest != nil {
+		ui.Say("Cancelling the spot request...")
+		if _, err := ec2conn.CancelSpotRequests([]string{s.spotRequest.SpotRequestId}); err != nil {
+			ui.Error(fmt.Sprintf("Error cancelling the spot request, may still be around: %s", err))
+			return
+		}
+		stateChange := StateChangeConf{
+			Pending: []string{"active", "open"},
+			Refresh: SpotRequestStateRefreshFunc(ec2conn, s.spotRequest.SpotRequestId),
+			Target:  "cancelled",
+		}
+
+		WaitForState(&stateChange)
+
 	}
 
-	stateChange := StateChangeConf{
-		Pending: []string{"pending", "running", "shutting-down", "stopped", "stopping"},
-		Refresh: InstanceStateRefreshFunc(ec2conn, s.instance),
-		Target:  "terminated",
-	}
+	// Terminate the source instance if it exists
+	if s.instance != nil {
 
-	WaitForState(&stateChange)
+		ui.Say("Terminating the source AWS instance...")
+		if _, err := ec2conn.TerminateInstances([]string{s.instance.InstanceId}); err != nil {
+			ui.Error(fmt.Sprintf("Error terminating instance, may still be around: %s", err))
+			return
+		}
+		stateChange := StateChangeConf{
+			Pending: []string{"pending", "running", "shutting-down", "stopped", "stopping"},
+			Refresh: InstanceStateRefreshFunc(ec2conn, s.instance),
+			Target:  "terminated",
+		}
+
+		WaitForState(&stateChange)
+	}
 }
diff --git a/builder/amazon/chroot/step_source_ami_info.go b/builder/amazon/common/step_source_ami_info.go
similarity index 66%
rename from builder/amazon/chroot/step_source_ami_info.go
rename to builder/amazon/common/step_source_ami_info.go
index 32ca5fd9c..c9f72123d 100644
--- a/builder/amazon/chroot/step_source_ami_info.go
+++ b/builder/amazon/common/step_source_ami_info.go
@@ -1,7 +1,8 @@
-package chroot
+package common
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
@@ -12,15 +13,17 @@ import (
 //
 // Produces:
 //   source_image *ec2.Image - the source AMI info
-type StepSourceAMIInfo struct{}
+type StepSourceAMIInfo struct {
+	SourceAmi          string
+	EnhancedNetworking bool
+}
 
 func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*Config)
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Inspecting the source AMI...")
-	imageResp, err := ec2conn.Images([]string{config.SourceAmi}, ec2.NewFilter())
+	imageResp, err := ec2conn.Images([]string{s.SourceAmi}, ec2.NewFilter())
 	if err != nil {
 		err := fmt.Errorf("Error querying AMI: %s", err)
 		state.Put("error", err)
@@ -29,7 +32,7 @@ func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	if len(imageResp.Images) == 0 {
-		err := fmt.Errorf("Source AMI '%s' was not found!", config.SourceAmi)
+		err := fmt.Errorf("Source AMI '%s' was not found!", s.SourceAmi)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
@@ -37,9 +40,10 @@ func (s *StepSourceAMIInfo) Run(state multistep.StateBag) multistep.StepAction {
 
 	image := &imageResp.Images[0]
 
-	// It must be EBS-backed otherwise the build won't work
-	if image.RootDeviceType != "ebs" {
-		err := fmt.Errorf("The root device of the source AMI must be EBS-backed.")
+	// Enhanced Networking (SriovNetSupport) can only be enabled on HVM AMIs.
+	// See http://goo.gl/icuXh5
+	if s.EnhancedNetworking && image.VirtualizationType != "hvm" {
+		err := fmt.Errorf("Cannot enable enhanced networking, source AMI '%s' is not HVM", s.SourceAmi)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
diff --git a/builder/amazon/ebs/builder.go b/builder/amazon/ebs/builder.go
index 2e898671e..889cc7b60 100644
--- a/builder/amazon/ebs/builder.go
+++ b/builder/amazon/ebs/builder.go
@@ -7,12 +7,13 @@ package ebs
 
 import (
 	"fmt"
+	"log"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	awscommon "github.com/mitchellh/packer/builder/amazon/common"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"log"
 )
 
 // The unique ID for this builder
@@ -49,6 +50,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	// Accumulate any errors
 	errs := common.CheckUnusedConfig(md)
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.BlockDevices.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
 
@@ -82,6 +84,10 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 
 	// Build the steps
 	steps := []multistep.Step{
+		&awscommon.StepSourceAMIInfo{
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+		},
 		&awscommon.StepKeyPair{
 			Debug:          b.config.PackerDebug,
 			DebugKeyPath:   fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
@@ -96,6 +102,8 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&awscommon.StepRunSourceInstance{
 			Debug:                    b.config.PackerDebug,
 			ExpectedRootDevice:       "ebs",
+			SpotPrice:                b.config.SpotPrice,
+			SpotPriceProduct:         b.config.SpotPriceAutoProduct,
 			InstanceType:             b.config.InstanceType,
 			UserData:                 b.config.UserData,
 			UserDataFile:             b.config.UserDataFile,
@@ -108,12 +116,15 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			Tags:                     b.config.RunTags,
 		},
 		&common.StepConnectSSH{
-			SSHAddress:     awscommon.SSHAddress(ec2conn, b.config.SSHPort),
+			SSHAddress: awscommon.SSHAddress(
+				ec2conn, b.config.SSHPort, b.config.SSHPrivateIp),
 			SSHConfig:      awscommon.SSHConfig(b.config.SSHUsername),
 			SSHWaitTimeout: b.config.SSHTimeout(),
 		},
 		&common.StepProvision{},
-		&stepStopInstance{},
+		&stepStopInstance{SpotPrice: b.config.SpotPrice},
+		// TODO(mitchellh): verify works with spots
+		&stepModifyInstance{},
 		&stepCreateAMI{},
 		&awscommon.StepAMIRegionCopy{
 			Regions: b.config.AMIRegions,
diff --git a/builder/amazon/ebs/hook.go b/builder/amazon/ebs/hook.go
deleted file mode 100644
index b33bfe86a..000000000
--- a/builder/amazon/ebs/hook.go
+++ /dev/null
@@ -1,4 +0,0 @@
-package ebs
-
-// This hook is fired prior to launching the EC2 instance.
-const HookPreLaunch = "amazonebs_pre_launch"
diff --git a/builder/amazon/ebs/step_create_ami.go b/builder/amazon/ebs/step_create_ami.go
index 4781cd692..967ad2d39 100644
--- a/builder/amazon/ebs/step_create_ami.go
+++ b/builder/amazon/ebs/step_create_ami.go
@@ -8,7 +8,9 @@ import (
 	"github.com/mitchellh/packer/packer"
 )
 
-type stepCreateAMI struct{}
+type stepCreateAMI struct {
+	image *ec2.Image
+}
 
 func (s *stepCreateAMI) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(config)
@@ -54,9 +56,38 @@ func (s *stepCreateAMI) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
+	imagesResp, err := ec2conn.Images([]string{createResp.ImageId}, nil)
+	if err != nil {
+		err := fmt.Errorf("Error searching for AMI: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+	s.image = &imagesResp.Images[0]
+
 	return multistep.ActionContinue
 }
 
-func (s *stepCreateAMI) Cleanup(multistep.StateBag) {
-	// No cleanup...
+func (s *stepCreateAMI) Cleanup(state multistep.StateBag) {
+	if s.image == nil {
+		return
+	}
+
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	_, halted := state.GetOk(multistep.StateHalted)
+	if !cancelled && !halted {
+		return
+	}
+
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Deregistering the AMI because cancelation or error...")
+	if resp, err := ec2conn.DeregisterImage(s.image.Id); err != nil {
+		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", err))
+		return
+	} else if resp.Return == false {
+		ui.Error(fmt.Sprintf("Error deregistering AMI, may still be around: %s", resp.Return))
+		return
+	}
 }
diff --git a/builder/amazon/ebs/step_modify_instance.go b/builder/amazon/ebs/step_modify_instance.go
new file mode 100644
index 000000000..21c5e7de9
--- /dev/null
+++ b/builder/amazon/ebs/step_modify_instance.go
@@ -0,0 +1,39 @@
+package ebs
+
+import (
+	"fmt"
+
+	"github.com/mitchellh/goamz/ec2"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+type stepModifyInstance struct{}
+
+func (s *stepModifyInstance) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(config)
+	ec2conn := state.Get("ec2").(*ec2.EC2)
+	instance := state.Get("instance").(*ec2.Instance)
+	ui := state.Get("ui").(packer.Ui)
+
+	// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
+	if config.AMIEnhancedNetworking {
+		ui.Say("Enabling Enhanced Networking...")
+		_, err := ec2conn.ModifyInstance(
+			instance.InstanceId,
+			&ec2.ModifyInstance{SriovNetSupport: true},
+		)
+		if err != nil {
+			err := fmt.Errorf("Error enabling Enhanced Networking on %s: %s", instance.InstanceId, err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *stepModifyInstance) Cleanup(state multistep.StateBag) {
+	// No cleanup...
+}
diff --git a/builder/amazon/ebs/step_stop_instance.go b/builder/amazon/ebs/step_stop_instance.go
index 8603fb807..09c19bddb 100644
--- a/builder/amazon/ebs/step_stop_instance.go
+++ b/builder/amazon/ebs/step_stop_instance.go
@@ -8,13 +8,20 @@ import (
 	"github.com/mitchellh/packer/packer"
 )
 
-type stepStopInstance struct{}
+type stepStopInstance struct {
+	SpotPrice string
+}
 
 func (s *stepStopInstance) Run(state multistep.StateBag) multistep.StepAction {
 	ec2conn := state.Get("ec2").(*ec2.EC2)
 	instance := state.Get("instance").(*ec2.Instance)
 	ui := state.Get("ui").(packer.Ui)
 
+	// Skip when it is a spot instance
+	if s.SpotPrice != "" {
+		return multistep.ActionContinue
+	}
+
 	// Stop the instance so we can create an AMI from it
 	ui.Say("Stopping the source instance...")
 	_, err := ec2conn.StopInstances(instance.InstanceId)
diff --git a/builder/amazon/instance/builder.go b/builder/amazon/instance/builder.go
index 81be72f72..1f5c1d9c8 100644
--- a/builder/amazon/instance/builder.go
+++ b/builder/amazon/instance/builder.go
@@ -5,14 +5,15 @@ package instance
 import (
 	"errors"
 	"fmt"
+	"log"
+	"os"
+	"strings"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	awscommon "github.com/mitchellh/packer/builder/amazon/common"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"strings"
 )
 
 // The unique ID for this builder
@@ -74,7 +75,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			"-s {{.SecretKey}} " +
 			"-d {{.BundleDirectory}} " +
 			"--batch " +
-			"--url {{.S3Endpoint}} " +
+			"--region {{.Region}} " +
 			"--retry"
 	}
 
@@ -87,7 +88,8 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			"-e {{.PrivatePath}}/* " +
 			"-d {{.Destination}} " +
 			"-p {{.Prefix}} " +
-			"--batch"
+			"--batch " +
+			"--no-filter"
 	}
 
 	if b.config.X509UploadPath == "" {
@@ -97,6 +99,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	// Accumulate any errors
 	errs := common.CheckUnusedConfig(md)
 	errs = packer.MultiErrorAppend(errs, b.config.AccessConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.BlockDevices.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.AMIConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
 
@@ -186,6 +189,10 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 
 	// Build the steps
 	steps := []multistep.Step{
+		&awscommon.StepSourceAMIInfo{
+			SourceAmi:          b.config.SourceAmi,
+			EnhancedNetworking: b.config.AMIEnhancedNetworking,
+		},
 		&awscommon.StepKeyPair{
 			Debug:          b.config.PackerDebug,
 			DebugKeyPath:   fmt.Sprintf("ec2_%s.pem", b.config.PackerBuildName),
@@ -199,7 +206,8 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		},
 		&awscommon.StepRunSourceInstance{
 			Debug:                    b.config.PackerDebug,
-			ExpectedRootDevice:       "instance-store",
+			SpotPrice:                b.config.SpotPrice,
+			SpotPriceProduct:         b.config.SpotPriceAutoProduct,
 			InstanceType:             b.config.InstanceType,
 			IamInstanceProfile:       b.config.IamInstanceProfile,
 			UserData:                 b.config.UserData,
@@ -212,14 +220,19 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			Tags:                     b.config.RunTags,
 		},
 		&common.StepConnectSSH{
-			SSHAddress:     awscommon.SSHAddress(ec2conn, b.config.SSHPort),
+			SSHAddress: awscommon.SSHAddress(
+				ec2conn, b.config.SSHPort, b.config.SSHPrivateIp),
 			SSHConfig:      awscommon.SSHConfig(b.config.SSHUsername),
 			SSHWaitTimeout: b.config.SSHTimeout(),
 		},
 		&common.StepProvision{},
 		&StepUploadX509Cert{},
-		&StepBundleVolume{},
-		&StepUploadBundle{},
+		&StepBundleVolume{
+			Debug: b.config.PackerDebug,
+		},
+		&StepUploadBundle{
+			Debug: b.config.PackerDebug,
+		},
 		&StepRegisterAMI{},
 		&awscommon.StepAMIRegionCopy{
 			Regions: b.config.AMIRegions,
diff --git a/builder/amazon/instance/step_bundle_volume.go b/builder/amazon/instance/step_bundle_volume.go
index 4dfbd4fc4..736e1adb2 100644
--- a/builder/amazon/instance/step_bundle_volume.go
+++ b/builder/amazon/instance/step_bundle_volume.go
@@ -2,6 +2,7 @@ package instance
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
@@ -17,7 +18,9 @@ type bundleCmdData struct {
 	PrivatePath  string
 }
 
-type StepBundleVolume struct{}
+type StepBundleVolume struct {
+	Debug bool
+}
 
 func (s *StepBundleVolume) Run(state multistep.StateBag) multistep.StepAction {
 	comm := state.Get("communicator").(packer.Communicator)
@@ -48,6 +51,11 @@ func (s *StepBundleVolume) Run(state multistep.StateBag) multistep.StepAction {
 	ui.Say("Bundling the volume...")
 	cmd := new(packer.RemoteCmd)
 	cmd.Command = config.BundleVolCommand
+
+	if s.Debug {
+		ui.Say(fmt.Sprintf("Running: %s", config.BundleVolCommand))
+	}
+
 	if err := cmd.StartWithUi(comm, ui); err != nil {
 		state.Put("error", fmt.Errorf("Error bundling volume: %s", err))
 		ui.Error(state.Get("error").(error).Error())
diff --git a/builder/amazon/instance/step_register_ami.go b/builder/amazon/instance/step_register_ami.go
index cadde6464..07040f417 100644
--- a/builder/amazon/instance/step_register_ami.go
+++ b/builder/amazon/instance/step_register_ami.go
@@ -2,6 +2,7 @@ package instance
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/goamz/ec2"
 	"github.com/mitchellh/multistep"
 	awscommon "github.com/mitchellh/packer/builder/amazon/common"
@@ -24,6 +25,11 @@ func (s *StepRegisterAMI) Run(state multistep.StateBag) multistep.StepAction {
 		VirtType:      config.AMIVirtType,
 	}
 
+	// Set SriovNetSupport to "simple". See http://goo.gl/icuXh5
+	if config.AMIEnhancedNetworking {
+		registerOpts.SriovNetSupport = "simple"
+	}
+
 	registerResp, err := ec2conn.RegisterImage(registerOpts)
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error registering AMI: %s", err))
diff --git a/builder/amazon/instance/step_upload_bundle.go b/builder/amazon/instance/step_upload_bundle.go
index 0ae1a404d..dbf6a0c29 100644
--- a/builder/amazon/instance/step_upload_bundle.go
+++ b/builder/amazon/instance/step_upload_bundle.go
@@ -2,6 +2,7 @@ package instance
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 )
@@ -11,11 +12,13 @@ type uploadCmdData struct {
 	BucketName      string
 	BundleDirectory string
 	ManifestPath    string
-	S3Endpoint      string
+	Region          string
 	SecretKey       string
 }
 
-type StepUploadBundle struct{}
+type StepUploadBundle struct {
+	Debug bool
+}
 
 func (s *StepUploadBundle) Run(state multistep.StateBag) multistep.StepAction {
 	comm := state.Get("communicator").(packer.Communicator)
@@ -37,7 +40,7 @@ func (s *StepUploadBundle) Run(state multistep.StateBag) multistep.StepAction {
 		BucketName:      config.S3Bucket,
 		BundleDirectory: config.BundleDestination,
 		ManifestPath:    manifestPath,
-		S3Endpoint:      region.S3Endpoint,
+		Region:          region.Name,
 		SecretKey:       config.SecretKey,
 	})
 	if err != nil {
@@ -49,6 +52,11 @@ func (s *StepUploadBundle) Run(state multistep.StateBag) multistep.StepAction {
 
 	ui.Say("Uploading the bundle...")
 	cmd := &packer.RemoteCmd{Command: config.BundleUploadCommand}
+
+	if s.Debug {
+		ui.Say(fmt.Sprintf("Running: %s", config.BundleUploadCommand))
+	}
+
 	if err := cmd.StartWithUi(comm, ui); err != nil {
 		state.Put("error", fmt.Errorf("Error uploading volume: %s", err))
 		ui.Error(state.Get("error").(error).Error())
diff --git a/builder/amazon/instance/step_upload_x509_cert.go b/builder/amazon/instance/step_upload_x509_cert.go
index d62ea8797..ee24cff98 100644
--- a/builder/amazon/instance/step_upload_x509_cert.go
+++ b/builder/amazon/instance/step_upload_x509_cert.go
@@ -45,5 +45,5 @@ func (s *StepUploadX509Cert) uploadSingle(comm packer.Communicator, dst, src str
 	}
 	defer f.Close()
 
-	return comm.Upload(dst, f)
+	return comm.Upload(dst, f, nil)
 }
diff --git a/builder/digitalocean/api.go b/builder/digitalocean/api.go
index 7aca1c14f..45b03684b 100644
--- a/builder/digitalocean/api.go
+++ b/builder/digitalocean/api.go
@@ -4,293 +4,65 @@
 
 package digitalocean
 
-import (
-	"encoding/json"
-	"errors"
-	"fmt"
-	"github.com/mitchellh/mapstructure"
-	"io/ioutil"
-	"log"
-	"net/http"
-	"net/url"
-	"strings"
-	"time"
-)
-
-const DIGITALOCEAN_API_URL = "https://api.digitalocean.com"
-
-type Image struct {
-	Id           uint
-	Name         string
-	Distribution string
-}
-
-type ImagesResp struct {
-	Images []Image
-}
-
 type Region struct {
-	Id   uint
-	Name string
+	Id        uint     `json:"id,omitempty"`        //only in v1 api
+	Slug      string   `json:"slug"`                //presen in both api
+	Name      string   `json:"name"`                //presen in both api
+	Sizes     []string `json:"sizes,omitempty"`     //only in v2 api
+	Available bool     `json:"available,omitempty"` //only in v2 api
+	Features  []string `json:"features,omitempty"`  //only in v2 api
 }
 
 type RegionsResp struct {
 	Regions []Region
 }
 
-type DigitalOceanClient struct {
-	// The http client for communicating
-	client *http.Client
-
-	// The base URL of the API
-	BaseURL string
-
-	// Credentials
-	ClientID string
-	APIKey   string
+type Size struct {
+	Id           uint     `json:"id,omitempty"`            //only in v1 api
+	Name         string   `json:"name,omitempty"`          //only in v1 api
+	Slug         string   `json:"slug"`                    //presen in both api
+	Memory       uint     `json:"memory,omitempty"`        //only in v2 api
+	VCPUS        uint     `json:"vcpus,omitempty"`         //only in v2 api
+	Disk         uint     `json:"disk,omitempty"`          //only in v2 api
+	Transfer     float64  `json:"transfer,omitempty"`      //only in v2 api
+	PriceMonthly float64  `json:"price_monthly,omitempty"` //only in v2 api
+	PriceHourly  float64  `json:"price_hourly,omitempty"`  //only in v2 api
+	Regions      []string `json:"regions,omitempty"`       //only in v2 api
 }
 
-// Creates a new client for communicating with DO
-func (d DigitalOceanClient) New(client string, key string) *DigitalOceanClient {
-	c := &DigitalOceanClient{
-		client: &http.Client{
-			Transport: &http.Transport{
-				Proxy: http.ProxyFromEnvironment,
-			},
-		},
-		BaseURL:  DIGITALOCEAN_API_URL,
-		ClientID: client,
-		APIKey:   key,
-	}
-	return c
+type SizesResp struct {
+	Sizes []Size
 }
 
-// Creates an SSH Key and returns it's id
-func (d DigitalOceanClient) CreateKey(name string, pub string) (uint, error) {
-	params := url.Values{}
-	params.Set("name", name)
-	params.Set("ssh_pub_key", pub)
-
-	body, err := NewRequest(d, "ssh_keys/new", params)
-	if err != nil {
-		return 0, err
-	}
-
-	// Read the SSH key's ID we just created
-	key := body["ssh_key"].(map[string]interface{})
-	keyId := key["id"].(float64)
-	return uint(keyId), nil
+type Image struct {
+	Id           uint     `json:"id"`                   //presen in both api
+	Name         string   `json:"name"`                 //presen in both api
+	Slug         string   `json:"slug"`                 //presen in both api
+	Distribution string   `json:"distribution"`         //presen in both api
+	Public       bool     `json:"public,omitempty"`     //only in v2 api
+	Regions      []string `json:"regions,omitempty"`    //only in v2 api
+	ActionIds    []string `json:"action_ids,omitempty"` //only in v2 api
+	CreatedAt    string   `json:"created_at,omitempty"` //only in v2 api
 }
 
-// Destroys an SSH key
-func (d DigitalOceanClient) DestroyKey(id uint) error {
-	path := fmt.Sprintf("ssh_keys/%v/destroy", id)
-	_, err := NewRequest(d, path, url.Values{})
-	return err
+type ImagesResp struct {
+	Images []Image
 }
 
-// Creates a droplet and returns it's id
-func (d DigitalOceanClient) CreateDroplet(name string, size uint, image uint, region uint, keyId uint, privateNetworking bool) (uint, error) {
-	params := url.Values{}
-	params.Set("name", name)
-	params.Set("size_id", fmt.Sprintf("%v", size))
-	params.Set("image_id", fmt.Sprintf("%v", image))
-	params.Set("region_id", fmt.Sprintf("%v", region))
-	params.Set("ssh_key_ids", fmt.Sprintf("%v", keyId))
-	params.Set("private_networking", fmt.Sprintf("%v", privateNetworking))
-
-	body, err := NewRequest(d, "droplets/new", params)
-	if err != nil {
-		return 0, err
-	}
-
-	// Read the Droplets ID
-	droplet := body["droplet"].(map[string]interface{})
-	dropletId := droplet["id"].(float64)
-	return uint(dropletId), err
-}
-
-// Destroys a droplet
-func (d DigitalOceanClient) DestroyDroplet(id uint) error {
-	path := fmt.Sprintf("droplets/%v/destroy", id)
-	_, err := NewRequest(d, path, url.Values{})
-	return err
-}
-
-// Powers off a droplet
-func (d DigitalOceanClient) PowerOffDroplet(id uint) error {
-	path := fmt.Sprintf("droplets/%v/power_off", id)
-
-	_, err := NewRequest(d, path, url.Values{})
-
-	return err
-}
-
-// Shutsdown a droplet. This is a "soft" shutdown.
-func (d DigitalOceanClient) ShutdownDroplet(id uint) error {
-	path := fmt.Sprintf("droplets/%v/shutdown", id)
-
-	_, err := NewRequest(d, path, url.Values{})
-
-	return err
-}
-
-// Creates a snaphot of a droplet by it's ID
-func (d DigitalOceanClient) CreateSnapshot(id uint, name string) error {
-	path := fmt.Sprintf("droplets/%v/snapshot", id)
-
-	params := url.Values{}
-	params.Set("name", name)
-
-	_, err := NewRequest(d, path, params)
-
-	return err
-}
-
-// Returns all available images.
-func (d DigitalOceanClient) Images() ([]Image, error) {
-	resp, err := NewRequest(d, "images", url.Values{})
-	if err != nil {
-		return nil, err
-	}
-
-	var result ImagesResp
-	if err := mapstructure.Decode(resp, &result); err != nil {
-		return nil, err
-	}
-
-	return result.Images, nil
-}
-
-// Destroys an image by its ID.
-func (d DigitalOceanClient) DestroyImage(id uint) error {
-	path := fmt.Sprintf("images/%d/destroy", id)
-	_, err := NewRequest(d, path, url.Values{})
-	return err
-}
-
-// Returns DO's string representation of status "off" "new" "active" etc.
-func (d DigitalOceanClient) DropletStatus(id uint) (string, string, error) {
-	path := fmt.Sprintf("droplets/%v", id)
-
-	body, err := NewRequest(d, path, url.Values{})
-	if err != nil {
-		return "", "", err
-	}
-
-	var ip string
-
-	// Read the droplet's "status"
-	droplet := body["droplet"].(map[string]interface{})
-	status := droplet["status"].(string)
-
-	if droplet["ip_address"] != nil {
-		ip = droplet["ip_address"].(string)
-	}
-
-	return ip, status, err
-}
-
-// Sends an api request and returns a generic map[string]interface of
-// the response.
-func NewRequest(d DigitalOceanClient, path string, params url.Values) (map[string]interface{}, error) {
-	client := d.client
-
-	// Add the authentication parameters
-	params.Set("client_id", d.ClientID)
-	params.Set("api_key", d.APIKey)
-
-	url := fmt.Sprintf("%s/%s?%s", DIGITALOCEAN_API_URL, path, params.Encode())
-
-	// Do some basic scrubbing so sensitive information doesn't appear in logs
-	scrubbedUrl := strings.Replace(url, d.ClientID, "CLIENT_ID", -1)
-	scrubbedUrl = strings.Replace(scrubbedUrl, d.APIKey, "API_KEY", -1)
-	log.Printf("sending new request to digitalocean: %s", scrubbedUrl)
-
-	var lastErr error
-	for attempts := 1; attempts < 10; attempts++ {
-		resp, err := client.Get(url)
-		if err != nil {
-			return nil, err
-		}
-
-		body, err := ioutil.ReadAll(resp.Body)
-		resp.Body.Close()
-		if err != nil {
-			return nil, err
-		}
-
-		log.Printf("response from digitalocean: %s", body)
-
-		var decodedResponse map[string]interface{}
-		err = json.Unmarshal(body, &decodedResponse)
-		if err != nil {
-			err = errors.New(fmt.Sprintf("Failed to decode JSON response (HTTP %v) from DigitalOcean: %s",
-				resp.StatusCode, body))
-			return decodedResponse, err
-		}
-
-		// Check for errors sent by digitalocean
-		status := decodedResponse["status"].(string)
-		if status == "OK" {
-			return decodedResponse, nil
-		}
-
-		if status == "ERROR" {
-			statusRaw, ok := decodedResponse["error_message"]
-			if ok {
-				status = statusRaw.(string)
-			} else {
-				status = fmt.Sprintf(
-					"Unknown error. Full response body: %s", body)
-			}
-		}
-
-		lastErr = errors.New(fmt.Sprintf("Received error from DigitalOcean (%d): %s",
-			resp.StatusCode, status))
-		log.Println(lastErr)
-		if strings.Contains(status, "a pending event") {
-			// Retry, DigitalOcean sends these dumb "pending event"
-			// errors all the time.
-			time.Sleep(5 * time.Second)
-			continue
-		}
-
-		// Some other kind of error. Just return.
-		return decodedResponse, lastErr
-	}
-
-	return nil, lastErr
-}
-
-// Returns all available regions.
-func (d DigitalOceanClient) Regions() ([]Region, error) {
-	resp, err := NewRequest(d, "regions", url.Values{})
-	if err != nil {
-		return nil, err
-	}
-
-	var result RegionsResp
-	if err := mapstructure.Decode(resp, &result); err != nil {
-		return nil, err
-	}
-
-	return result.Regions, nil
-}
-
-func (d DigitalOceanClient) RegionName(region_id uint) (string, error) {
-	regions, err := d.Regions()
-	if err != nil {
-		return "", err
-	}
-
-	for _, region := range regions {
-		if region.Id == region_id {
-			return region.Name, nil
-		}
-	}
-
-	err = errors.New(fmt.Sprintf("Unknown region id %v", region_id))
-
-	return "", err
+type DigitalOceanClient interface {
+	CreateKey(string, string) (uint, error)
+	DestroyKey(uint) error
+	CreateDroplet(string, string, string, string, uint, bool) (uint, error)
+	DestroyDroplet(uint) error
+	PowerOffDroplet(uint) error
+	ShutdownDroplet(uint) error
+	CreateSnapshot(uint, string) error
+	Images() ([]Image, error)
+	DestroyImage(uint) error
+	DropletStatus(uint) (string, string, error)
+	Image(string) (Image, error)
+	Regions() ([]Region, error)
+	Region(string) (Region, error)
+	Sizes() ([]Size, error)
+	Size(string) (Size, error)
 }
diff --git a/builder/digitalocean/api_v1.go b/builder/digitalocean/api_v1.go
new file mode 100644
index 000000000..23746d11f
--- /dev/null
+++ b/builder/digitalocean/api_v1.go
@@ -0,0 +1,382 @@
+// All of the methods used to communicate with the digital_ocean API
+// are here. Their API is on a path to V2, so just plain JSON is used
+// in place of a proper client library for now.
+
+package digitalocean
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/mitchellh/mapstructure"
+)
+
+type DigitalOceanClientV1 struct {
+	// The http client for communicating
+	client *http.Client
+
+	// Credentials
+	ClientID string
+	APIKey   string
+	// The base URL of the API
+	APIURL string
+}
+
+// Creates a new client for communicating with DO
+func DigitalOceanClientNewV1(client string, key string, url string) *DigitalOceanClientV1 {
+	c := &DigitalOceanClientV1{
+		client: &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+			},
+		},
+		APIURL:   url,
+		ClientID: client,
+		APIKey:   key,
+	}
+	return c
+}
+
+// Creates an SSH Key and returns it's id
+func (d DigitalOceanClientV1) CreateKey(name string, pub string) (uint, error) {
+	params := url.Values{}
+	params.Set("name", name)
+	params.Set("ssh_pub_key", pub)
+
+	body, err := NewRequestV1(d, "ssh_keys/new", params)
+	if err != nil {
+		return 0, err
+	}
+
+	// Read the SSH key's ID we just created
+	key := body["ssh_key"].(map[string]interface{})
+	keyId := key["id"].(float64)
+	return uint(keyId), nil
+}
+
+// Destroys an SSH key
+func (d DigitalOceanClientV1) DestroyKey(id uint) error {
+	path := fmt.Sprintf("ssh_keys/%v/destroy", id)
+	_, err := NewRequestV1(d, path, url.Values{})
+	return err
+}
+
+// Creates a droplet and returns it's id
+func (d DigitalOceanClientV1) CreateDroplet(name string, size string, image string, region string, keyId uint, privateNetworking bool) (uint, error) {
+	params := url.Values{}
+	params.Set("name", name)
+
+	found_size, err := d.Size(size)
+	if err != nil {
+		return 0, fmt.Errorf("Invalid size or lookup failure: '%s': %s", size, err)
+	}
+
+	found_image, err := d.Image(image)
+	if err != nil {
+		return 0, fmt.Errorf("Invalid image or lookup failure: '%s': %s", image, err)
+	}
+
+	found_region, err := d.Region(region)
+	if err != nil {
+		return 0, fmt.Errorf("Invalid region or lookup failure: '%s': %s", region, err)
+	}
+
+	params.Set("size_slug", found_size.Slug)
+	params.Set("image_slug", found_image.Slug)
+	params.Set("region_slug", found_region.Slug)
+	params.Set("ssh_key_ids", fmt.Sprintf("%v", keyId))
+	params.Set("private_networking", fmt.Sprintf("%v", privateNetworking))
+
+	body, err := NewRequestV1(d, "droplets/new", params)
+	if err != nil {
+		return 0, err
+	}
+
+	// Read the Droplets ID
+	droplet := body["droplet"].(map[string]interface{})
+	dropletId := droplet["id"].(float64)
+	return uint(dropletId), err
+}
+
+// Destroys a droplet
+func (d DigitalOceanClientV1) DestroyDroplet(id uint) error {
+	path := fmt.Sprintf("droplets/%v/destroy", id)
+	_, err := NewRequestV1(d, path, url.Values{})
+	return err
+}
+
+// Powers off a droplet
+func (d DigitalOceanClientV1) PowerOffDroplet(id uint) error {
+	path := fmt.Sprintf("droplets/%v/power_off", id)
+	_, err := NewRequestV1(d, path, url.Values{})
+	return err
+}
+
+// Shutsdown a droplet. This is a "soft" shutdown.
+func (d DigitalOceanClientV1) ShutdownDroplet(id uint) error {
+	path := fmt.Sprintf("droplets/%v/shutdown", id)
+	_, err := NewRequestV1(d, path, url.Values{})
+	return err
+}
+
+// Creates a snaphot of a droplet by it's ID
+func (d DigitalOceanClientV1) CreateSnapshot(id uint, name string) error {
+	path := fmt.Sprintf("droplets/%v/snapshot", id)
+
+	params := url.Values{}
+	params.Set("name", name)
+
+	_, err := NewRequestV1(d, path, params)
+
+	return err
+}
+
+// Returns all available images.
+func (d DigitalOceanClientV1) Images() ([]Image, error) {
+	resp, err := NewRequestV1(d, "images", url.Values{})
+	if err != nil {
+		return nil, err
+	}
+
+	var result ImagesResp
+	if err := mapstructure.Decode(resp, &result); err != nil {
+		return nil, err
+	}
+
+	return result.Images, nil
+}
+
+// Destroys an image by its ID.
+func (d DigitalOceanClientV1) DestroyImage(id uint) error {
+	path := fmt.Sprintf("images/%d/destroy", id)
+	_, err := NewRequestV1(d, path, url.Values{})
+	return err
+}
+
+// Returns DO's string representation of status "off" "new" "active" etc.
+func (d DigitalOceanClientV1) DropletStatus(id uint) (string, string, error) {
+	path := fmt.Sprintf("droplets/%v", id)
+
+	body, err := NewRequestV1(d, path, url.Values{})
+	if err != nil {
+		return "", "", err
+	}
+
+	var ip string
+
+	// Read the droplet's "status"
+	droplet := body["droplet"].(map[string]interface{})
+	status := droplet["status"].(string)
+
+	if droplet["ip_address"] != nil {
+		ip = droplet["ip_address"].(string)
+	}
+
+	return ip, status, err
+}
+
+// Sends an api request and returns a generic map[string]interface of
+// the response.
+func NewRequestV1(d DigitalOceanClientV1, path string, params url.Values) (map[string]interface{}, error) {
+	client := d.client
+
+	// Add the authentication parameters
+	params.Set("client_id", d.ClientID)
+	params.Set("api_key", d.APIKey)
+
+	url := fmt.Sprintf("%s/%s?%s", d.APIURL, path, params.Encode())
+
+	// Do some basic scrubbing so sensitive information doesn't appear in logs
+	scrubbedUrl := strings.Replace(url, d.ClientID, "CLIENT_ID", -1)
+	scrubbedUrl = strings.Replace(scrubbedUrl, d.APIKey, "API_KEY", -1)
+	log.Printf("sending new request to digitalocean: %s", scrubbedUrl)
+
+	var lastErr error
+	for attempts := 1; attempts < 10; attempts++ {
+		resp, err := client.Get(url)
+		if err != nil {
+			return nil, err
+		}
+
+		body, err := ioutil.ReadAll(resp.Body)
+		resp.Body.Close()
+		if err != nil {
+			return nil, err
+		}
+
+		log.Printf("response from digitalocean: %s", body)
+
+		var decodedResponse map[string]interface{}
+		err = json.Unmarshal(body, &decodedResponse)
+		if err != nil {
+			err = errors.New(fmt.Sprintf("Failed to decode JSON response (HTTP %v) from DigitalOcean: %s",
+				resp.StatusCode, body))
+			return decodedResponse, err
+		}
+
+		// Check for errors sent by digitalocean
+		status := decodedResponse["status"].(string)
+		if status == "OK" {
+			return decodedResponse, nil
+		}
+
+		if status == "ERROR" {
+			statusRaw, ok := decodedResponse["error_message"]
+			if ok {
+				status = statusRaw.(string)
+			} else {
+				status = fmt.Sprintf(
+					"Unknown error. Full response body: %s", body)
+			}
+		}
+
+		lastErr = errors.New(fmt.Sprintf("Received error from DigitalOcean (%d): %s",
+			resp.StatusCode, status))
+		log.Println(lastErr)
+		if strings.Contains(status, "a pending event") {
+			// Retry, DigitalOcean sends these dumb "pending event"
+			// errors all the time.
+			time.Sleep(5 * time.Second)
+			continue
+		}
+
+		// Some other kind of error. Just return.
+		return decodedResponse, lastErr
+	}
+
+	return nil, lastErr
+}
+
+func (d DigitalOceanClientV1) Image(slug_or_name_or_id string) (Image, error) {
+	images, err := d.Images()
+	if err != nil {
+		return Image{}, err
+	}
+
+	for _, image := range images {
+		if strings.EqualFold(image.Slug, slug_or_name_or_id) {
+			return image, nil
+		}
+	}
+
+	for _, image := range images {
+		if strings.EqualFold(image.Name, slug_or_name_or_id) {
+			return image, nil
+		}
+	}
+
+	for _, image := range images {
+		id, err := strconv.Atoi(slug_or_name_or_id)
+		if err == nil {
+			if image.Id == uint(id) {
+				return image, nil
+			}
+		}
+	}
+
+	err = errors.New(fmt.Sprintf("Unknown image '%v'", slug_or_name_or_id))
+
+	return Image{}, err
+}
+
+// Returns all available regions.
+func (d DigitalOceanClientV1) Regions() ([]Region, error) {
+	resp, err := NewRequestV1(d, "regions", url.Values{})
+	if err != nil {
+		return nil, err
+	}
+
+	var result RegionsResp
+	if err := mapstructure.Decode(resp, &result); err != nil {
+		return nil, err
+	}
+
+	return result.Regions, nil
+}
+
+func (d DigitalOceanClientV1) Region(slug_or_name_or_id string) (Region, error) {
+	regions, err := d.Regions()
+	if err != nil {
+		return Region{}, err
+	}
+
+	for _, region := range regions {
+		if strings.EqualFold(region.Slug, slug_or_name_or_id) {
+			return region, nil
+		}
+	}
+
+	for _, region := range regions {
+		if strings.EqualFold(region.Name, slug_or_name_or_id) {
+			return region, nil
+		}
+	}
+
+	for _, region := range regions {
+		id, err := strconv.Atoi(slug_or_name_or_id)
+		if err == nil {
+			if region.Id == uint(id) {
+				return region, nil
+			}
+		}
+	}
+
+	err = errors.New(fmt.Sprintf("Unknown region '%v'", slug_or_name_or_id))
+
+	return Region{}, err
+}
+
+// Returns all available sizes.
+func (d DigitalOceanClientV1) Sizes() ([]Size, error) {
+	resp, err := NewRequestV1(d, "sizes", url.Values{})
+	if err != nil {
+		return nil, err
+	}
+
+	var result SizesResp
+	if err := mapstructure.Decode(resp, &result); err != nil {
+		return nil, err
+	}
+
+	return result.Sizes, nil
+}
+
+func (d DigitalOceanClientV1) Size(slug_or_name_or_id string) (Size, error) {
+	sizes, err := d.Sizes()
+	if err != nil {
+		return Size{}, err
+	}
+
+	for _, size := range sizes {
+		if strings.EqualFold(size.Slug, slug_or_name_or_id) {
+			return size, nil
+		}
+	}
+
+	for _, size := range sizes {
+		if strings.EqualFold(size.Name, slug_or_name_or_id) {
+			return size, nil
+		}
+	}
+
+	for _, size := range sizes {
+		id, err := strconv.Atoi(slug_or_name_or_id)
+		if err == nil {
+			if size.Id == uint(id) {
+				return size, nil
+			}
+		}
+	}
+
+	err = errors.New(fmt.Sprintf("Unknown size '%v'", slug_or_name_or_id))
+
+	return Size{}, err
+}
diff --git a/builder/digitalocean/api_v2.go b/builder/digitalocean/api_v2.go
new file mode 100644
index 000000000..23806df6f
--- /dev/null
+++ b/builder/digitalocean/api_v2.go
@@ -0,0 +1,448 @@
+// are here. Their API is on a path to V2, so just plain JSON is used
+// in place of a proper client library for now.
+
+package digitalocean
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+)
+
+type DigitalOceanClientV2 struct {
+	// The http client for communicating
+	client *http.Client
+
+	// Credentials
+	APIToken string
+
+	// The base URL of the API
+	APIURL string
+}
+
+// Creates a new client for communicating with DO
+func DigitalOceanClientNewV2(token string, url string) *DigitalOceanClientV2 {
+	c := &DigitalOceanClientV2{
+		client: &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+			},
+		},
+		APIURL:   url,
+		APIToken: token,
+	}
+	return c
+}
+
+// Creates an SSH Key and returns it's id
+func (d DigitalOceanClientV2) CreateKey(name string, pub string) (uint, error) {
+	type KeyReq struct {
+		Name      string `json:"name"`
+		PublicKey string `json:"public_key"`
+	}
+	type KeyRes struct {
+		SSHKey struct {
+			Id          uint
+			Name        string
+			Fingerprint string
+			PublicKey   string `json:"public_key"`
+		} `json:"ssh_key"`
+	}
+	req := &KeyReq{Name: name, PublicKey: pub}
+	res := KeyRes{}
+	err := NewRequestV2(d, "v2/account/keys", "POST", req, &res)
+	if err != nil {
+		return 0, err
+	}
+
+	return res.SSHKey.Id, err
+}
+
+// Destroys an SSH key
+func (d DigitalOceanClientV2) DestroyKey(id uint) error {
+	path := fmt.Sprintf("v2/account/keys/%v", id)
+	return NewRequestV2(d, path, "DELETE", nil, nil)
+}
+
+// Creates a droplet and returns it's id
+func (d DigitalOceanClientV2) CreateDroplet(name string, size string, image string, region string, keyId uint, privateNetworking bool) (uint, error) {
+	type DropletReq struct {
+		Name              string   `json:"name"`
+		Region            string   `json:"region"`
+		Size              string   `json:"size"`
+		Image             string   `json:"image"`
+		SSHKeys           []string `json:"ssh_keys,omitempty"`
+		Backups           bool     `json:"backups,omitempty"`
+		IPv6              bool     `json:"ipv6,omitempty"`
+		PrivateNetworking bool     `json:"private_networking,omitempty"`
+	}
+	type DropletRes struct {
+		Droplet struct {
+			Id       uint
+			Name     string
+			Memory   uint
+			VCPUS    uint `json:"vcpus"`
+			Disk     uint
+			Region   Region
+			Image    Image
+			Size     Size
+			Locked   bool
+			CreateAt string `json:"created_at"`
+			Status   string
+			Networks struct {
+				V4 []struct {
+					IPAddr  string `json:"ip_address"`
+					Netmask string
+					Gateway string
+					Type    string
+				} `json:"v4,omitempty"`
+				V6 []struct {
+					IPAddr  string `json:"ip_address"`
+					CIDR    uint   `json:"cidr"`
+					Gateway string
+					Type    string
+				} `json:"v6,omitempty"`
+			}
+			Kernel struct {
+				Id      uint
+				Name    string
+				Version string
+			}
+			BackupIds   []uint
+			SnapshotIds []uint
+			ActionIds   []uint
+			Features    []string `json:"features,omitempty"`
+		}
+	}
+	req := &DropletReq{Name: name}
+	res := DropletRes{}
+
+	found_size, err := d.Size(size)
+	if err != nil {
+		return 0, fmt.Errorf("Invalid size or lookup failure: '%s': %s", size, err)
+	}
+
+	found_image, err := d.Image(image)
+	if err != nil {
+		return 0, fmt.Errorf("Invalid image or lookup failure: '%s': %s", image, err)
+	}
+
+	found_region, err := d.Region(region)
+	if err != nil {
+		return 0, fmt.Errorf("Invalid region or lookup failure: '%s': %s", region, err)
+	}
+
+	req.Size = found_size.Slug
+	req.Image = found_image.Slug
+	req.Region = found_region.Slug
+	req.SSHKeys = []string{fmt.Sprintf("%v", keyId)}
+	req.PrivateNetworking = privateNetworking
+
+	err = NewRequestV2(d, "v2/droplets", "POST", req, &res)
+	if err != nil {
+		return 0, err
+	}
+
+	return res.Droplet.Id, err
+}
+
+// Destroys a droplet
+func (d DigitalOceanClientV2) DestroyDroplet(id uint) error {
+	path := fmt.Sprintf("v2/droplets/%v", id)
+	return NewRequestV2(d, path, "DELETE", nil, nil)
+}
+
+// Powers off a droplet
+func (d DigitalOceanClientV2) PowerOffDroplet(id uint) error {
+	type ActionReq struct {
+		Type string `json:"type"`
+	}
+	type ActionRes struct {
+	}
+	req := &ActionReq{Type: "power_off"}
+	path := fmt.Sprintf("v2/droplets/%v/actions", id)
+	return NewRequestV2(d, path, "POST", req, nil)
+}
+
+// Shutsdown a droplet. This is a "soft" shutdown.
+func (d DigitalOceanClientV2) ShutdownDroplet(id uint) error {
+	type ActionReq struct {
+		Type string `json:"type"`
+	}
+	type ActionRes struct {
+	}
+	req := &ActionReq{Type: "shutdown"}
+
+	path := fmt.Sprintf("v2/droplets/%v/actions", id)
+	return NewRequestV2(d, path, "POST", req, nil)
+}
+
+// Creates a snaphot of a droplet by it's ID
+func (d DigitalOceanClientV2) CreateSnapshot(id uint, name string) error {
+	type ActionReq struct {
+		Type string `json:"type"`
+		Name string `json:"name"`
+	}
+	type ActionRes struct {
+	}
+	req := &ActionReq{Type: "snapshot", Name: name}
+	path := fmt.Sprintf("v2/droplets/%v/actions", id)
+	return NewRequestV2(d, path, "POST", req, nil)
+}
+
+// Returns all available images.
+func (d DigitalOceanClientV2) Images() ([]Image, error) {
+	res := ImagesResp{}
+
+	err := NewRequestV2(d, "v2/images?per_page=200", "GET", nil, &res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Images, nil
+}
+
+// Destroys an image by its ID.
+func (d DigitalOceanClientV2) DestroyImage(id uint) error {
+	path := fmt.Sprintf("v2/images/%d", id)
+	return NewRequestV2(d, path, "DELETE", nil, nil)
+}
+
+// Returns DO's string representation of status "off" "new" "active" etc.
+func (d DigitalOceanClientV2) DropletStatus(id uint) (string, string, error) {
+	path := fmt.Sprintf("v2/droplets/%v", id)
+	type DropletRes struct {
+		Droplet struct {
+			Id       uint
+			Name     string
+			Memory   uint
+			VCPUS    uint `json:"vcpus"`
+			Disk     uint
+			Region   Region
+			Image    Image
+			Size     Size
+			Locked   bool
+			CreateAt string `json:"created_at"`
+			Status   string
+			Networks struct {
+				V4 []struct {
+					IPAddr  string `json:"ip_address"`
+					Netmask string
+					Gateway string
+					Type    string
+				} `json:"v4,omitempty"`
+				V6 []struct {
+					IPAddr  string `json:"ip_address"`
+					CIDR    uint   `json:"cidr"`
+					Gateway string
+					Type    string
+				} `json:"v6,omitempty"`
+			}
+			Kernel struct {
+				Id      uint
+				Name    string
+				Version string
+			}
+			BackupIds   []uint
+			SnapshotIds []uint
+			ActionIds   []uint
+			Features    []string `json:"features,omitempty"`
+		}
+	}
+	res := DropletRes{}
+	err := NewRequestV2(d, path, "GET", nil, &res)
+	if err != nil {
+		return "", "", err
+	}
+	var ip string
+
+	if len(res.Droplet.Networks.V4) > 0 {
+		ip = res.Droplet.Networks.V4[0].IPAddr
+	}
+
+	return ip, res.Droplet.Status, err
+}
+
+// Sends an api request and returns a generic map[string]interface of
+// the response.
+func NewRequestV2(d DigitalOceanClientV2, path string, method string, req interface{}, res interface{}) error {
+	var err error
+	var request *http.Request
+
+	client := d.client
+
+	buf := new(bytes.Buffer)
+	// Add the authentication parameters
+	url := fmt.Sprintf("%s/%s", d.APIURL, path)
+	if req != nil {
+		enc := json.NewEncoder(buf)
+		enc.Encode(req)
+		defer buf.Reset()
+		request, err = http.NewRequest(method, url, buf)
+	} else {
+		request, err = http.NewRequest(method, url, nil)
+	}
+	if err != nil {
+		return err
+	}
+	// Add the authentication parameters
+	request.Header.Add("Authorization", "Bearer "+d.APIToken)
+
+	log.Printf("sending new request to digitalocean: %s", url)
+
+	resp, err := client.Do(request)
+	if err != nil {
+		return err
+	}
+
+	if method == "DELETE" && resp.StatusCode == 204 {
+		if resp.Body != nil {
+			resp.Body.Close()
+		}
+		return nil
+	}
+
+	if resp.Body == nil {
+		return errors.New("Request returned empty body")
+	}
+
+	body, err := ioutil.ReadAll(resp.Body)
+	resp.Body.Close()
+	if err != nil {
+		return err
+	}
+
+	log.Printf("response from digitalocean: %s", body)
+
+	err = json.Unmarshal(body, &res)
+	if err != nil {
+		return errors.New(fmt.Sprintf("Failed to decode JSON response %s (HTTP %v) from DigitalOcean: %s", err.Error(),
+			resp.StatusCode, body))
+	}
+
+	return nil
+}
+
+func (d DigitalOceanClientV2) Image(slug_or_name_or_id string) (Image, error) {
+	images, err := d.Images()
+	if err != nil {
+		return Image{}, err
+	}
+
+	for _, image := range images {
+		if strings.EqualFold(image.Slug, slug_or_name_or_id) {
+			return image, nil
+		}
+	}
+
+	for _, image := range images {
+		if strings.EqualFold(image.Name, slug_or_name_or_id) {
+			return image, nil
+		}
+	}
+
+	for _, image := range images {
+		id, err := strconv.Atoi(slug_or_name_or_id)
+		if err == nil {
+			if image.Id == uint(id) {
+				return image, nil
+			}
+		}
+	}
+
+	err = errors.New(fmt.Sprintf("Unknown image '%v'", slug_or_name_or_id))
+
+	return Image{}, err
+}
+
+// Returns all available regions.
+func (d DigitalOceanClientV2) Regions() ([]Region, error) {
+	res := RegionsResp{}
+	err := NewRequestV2(d, "v2/regions?per_page=200", "GET", nil, &res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Regions, nil
+}
+
+func (d DigitalOceanClientV2) Region(slug_or_name_or_id string) (Region, error) {
+	regions, err := d.Regions()
+	if err != nil {
+		return Region{}, err
+	}
+
+	for _, region := range regions {
+		if strings.EqualFold(region.Slug, slug_or_name_or_id) {
+			return region, nil
+		}
+	}
+
+	for _, region := range regions {
+		if strings.EqualFold(region.Name, slug_or_name_or_id) {
+			return region, nil
+		}
+	}
+
+	for _, region := range regions {
+		id, err := strconv.Atoi(slug_or_name_or_id)
+		if err == nil {
+			if region.Id == uint(id) {
+				return region, nil
+			}
+		}
+	}
+
+	err = errors.New(fmt.Sprintf("Unknown region '%v'", slug_or_name_or_id))
+
+	return Region{}, err
+}
+
+// Returns all available sizes.
+func (d DigitalOceanClientV2) Sizes() ([]Size, error) {
+	res := SizesResp{}
+	err := NewRequestV2(d, "v2/sizes?per_page=200", "GET", nil, &res)
+	if err != nil {
+		return nil, err
+	}
+
+	return res.Sizes, nil
+}
+
+func (d DigitalOceanClientV2) Size(slug_or_name_or_id string) (Size, error) {
+	sizes, err := d.Sizes()
+	if err != nil {
+		return Size{}, err
+	}
+
+	for _, size := range sizes {
+		if strings.EqualFold(size.Slug, slug_or_name_or_id) {
+			return size, nil
+		}
+	}
+
+	for _, size := range sizes {
+		if strings.EqualFold(size.Name, slug_or_name_or_id) {
+			return size, nil
+		}
+	}
+
+	for _, size := range sizes {
+		id, err := strconv.Atoi(slug_or_name_or_id)
+		if err == nil {
+			if size.Id == uint(id) {
+				return size, nil
+			}
+		}
+	}
+
+	err = errors.New(fmt.Sprintf("Unknown size '%v'", slug_or_name_or_id))
+
+	return Size{}, err
+}
diff --git a/builder/digitalocean/artifact.go b/builder/digitalocean/artifact.go
index 06f09fe40..3f756a05d 100644
--- a/builder/digitalocean/artifact.go
+++ b/builder/digitalocean/artifact.go
@@ -15,11 +15,8 @@ type Artifact struct {
 	// The name of the region
 	regionName string
 
-	// The ID of the region
-	regionId uint
-
 	// The client for making API calls
-	client *DigitalOceanClient
+	client DigitalOceanClient
 }
 
 func (*Artifact) BuilderId() string {
@@ -40,6 +37,10 @@ func (a *Artifact) String() string {
 	return fmt.Sprintf("A snapshot was created: '%v' in region '%v'", a.snapshotName, a.regionName)
 }
 
+func (a *Artifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *Artifact) Destroy() error {
 	log.Printf("Destroying image: %d (%s)", a.snapshotId, a.snapshotName)
 	return a.client.DestroyImage(a.snapshotId)
diff --git a/builder/digitalocean/artifact_test.go b/builder/digitalocean/artifact_test.go
index 0b4427eae..83681b3fa 100644
--- a/builder/digitalocean/artifact_test.go
+++ b/builder/digitalocean/artifact_test.go
@@ -14,7 +14,7 @@ func TestArtifact_Impl(t *testing.T) {
 }
 
 func TestArtifactString(t *testing.T) {
-	a := &Artifact{"packer-foobar", 42, "San Francisco", 3, nil}
+	a := &Artifact{"packer-foobar", 42, "San Francisco", nil}
 	expected := "A snapshot was created: 'packer-foobar' in region 'San Francisco'"
 
 	if a.String() != expected {
diff --git a/builder/digitalocean/builder.go b/builder/digitalocean/builder.go
index ef90aab85..5b84755ae 100644
--- a/builder/digitalocean/builder.go
+++ b/builder/digitalocean/builder.go
@@ -6,15 +6,28 @@ package digitalocean
 import (
 	"errors"
 	"fmt"
+	"log"
+	"os"
+	"time"
+
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
-	"log"
-	"os"
-	"time"
 )
 
+// see https://api.digitalocean.com/images/?client_id=[client_id]&api_key=[api_key]
+// name="Ubuntu 12.04.4 x64", id=3101045,
+const DefaultImage = "ubuntu-12-04-x64"
+
+// see https://api.digitalocean.com/regions/?client_id=[client_id]&api_key=[api_key]
+// name="New York", id=1
+const DefaultRegion = "nyc1"
+
+// see https://api.digitalocean.com/sizes/?client_id=[client_id]&api_key=[api_key]
+// name="512MB", id=66 (the smallest droplet size)
+const DefaultSize = "512mb"
+
 // The unique id for the builder
 const BuilderId = "pearkes.digitalocean"
 
@@ -26,10 +39,16 @@ type config struct {
 
 	ClientID string `mapstructure:"client_id"`
 	APIKey   string `mapstructure:"api_key"`
+	APIURL   string `mapstructure:"api_url"`
+	APIToken string `mapstructure:"api_token"`
 	RegionID uint   `mapstructure:"region_id"`
 	SizeID   uint   `mapstructure:"size_id"`
 	ImageID  uint   `mapstructure:"image_id"`
 
+	Region string `mapstructure:"region"`
+	Size   string `mapstructure:"size"`
+	Image  string `mapstructure:"image"`
+
 	PrivateNetworking bool   `mapstructure:"private_networking"`
 	SnapshotName      string `mapstructure:"snapshot_name"`
 	DropletName       string `mapstructure:"droplet_name"`
@@ -78,19 +97,38 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.ClientID = os.Getenv("DIGITALOCEAN_CLIENT_ID")
 	}
 
-	if b.config.RegionID == 0 {
-		// Default to Region "New York"
-		b.config.RegionID = 1
+	if b.config.APIURL == "" {
+		// Default to environment variable for api_url, if it exists
+		b.config.APIURL = os.Getenv("DIGITALOCEAN_API_URL")
 	}
 
-	if b.config.SizeID == 0 {
-		// Default to 512mb, the smallest droplet size
-		b.config.SizeID = 66
+	if b.config.APIToken == "" {
+		// Default to environment variable for api_token, if it exists
+		b.config.APIToken = os.Getenv("DIGITALOCEAN_API_TOKEN")
 	}
 
-	if b.config.ImageID == 0 {
-		// Default to base image "Ubuntu 12.04.4 x64 (id: 3101045)"
-		b.config.ImageID = 3101045
+	if b.config.Region == "" {
+		if b.config.RegionID != 0 {
+			b.config.Region = fmt.Sprintf("%v", b.config.RegionID)
+		} else {
+			b.config.Region = DefaultRegion
+		}
+	}
+
+	if b.config.Size == "" {
+		if b.config.SizeID != 0 {
+			b.config.Size = fmt.Sprintf("%v", b.config.SizeID)
+		} else {
+			b.config.Size = DefaultSize
+		}
+	}
+
+	if b.config.Image == "" {
+		if b.config.ImageID != 0 {
+			b.config.Image = fmt.Sprintf("%v", b.config.ImageID)
+		} else {
+			b.config.Image = DefaultImage
+		}
 	}
 
 	if b.config.SnapshotName == "" {
@@ -126,8 +164,13 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	}
 
 	templates := map[string]*string{
+		"region":        &b.config.Region,
+		"size":          &b.config.Size,
+		"image":         &b.config.Image,
 		"client_id":     &b.config.ClientID,
 		"api_key":       &b.config.APIKey,
+		"api_url":       &b.config.APIURL,
+		"api_token":     &b.config.APIToken,
 		"snapshot_name": &b.config.SnapshotName,
 		"droplet_name":  &b.config.DropletName,
 		"ssh_username":  &b.config.SSHUsername,
@@ -144,15 +187,21 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	// Required configurations that will display errors if not set
-	if b.config.ClientID == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a client_id must be specified"))
+	if b.config.APIToken == "" {
+		// Required configurations that will display errors if not set
+		if b.config.ClientID == "" {
+			errs = packer.MultiErrorAppend(
+				errs, errors.New("a client_id for v1 auth or api_token for v2 auth must be specified"))
+		}
+
+		if b.config.APIKey == "" {
+			errs = packer.MultiErrorAppend(
+				errs, errors.New("a api_key for v1 auth or api_token for v2 auth must be specified"))
+		}
 	}
 
-	if b.config.APIKey == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("an api_key must be specified"))
+	if b.config.APIURL == "" {
+		b.config.APIURL = "https://api.digitalocean.com"
 	}
 
 	sshTimeout, err := time.ParseDuration(b.config.RawSSHTimeout)
@@ -178,8 +227,13 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	var client DigitalOceanClient
 	// Initialize the DO API client
-	client := DigitalOceanClient{}.New(b.config.ClientID, b.config.APIKey)
+	if b.config.APIToken == "" {
+		client = DigitalOceanClientNewV1(b.config.ClientID, b.config.APIKey, b.config.APIURL)
+	} else {
+		client = DigitalOceanClientNewV2(b.config.APIToken, b.config.APIURL)
+	}
 
 	// Set up the state
 	state := new(multistep.BasicStateBag)
@@ -226,9 +280,18 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		return nil, nil
 	}
 
-	region_id := state.Get("region_id").(uint)
+	sregion := state.Get("region")
+
+	var region string
+
+	if sregion != nil {
+		region = sregion.(string)
+	} else {
+		region = fmt.Sprintf("%v", state.Get("region_id").(uint))
+	}
+
+	found_region, err := client.Region(region)
 
-	regionName, err := client.RegionName(region_id)
 	if err != nil {
 		return nil, err
 	}
@@ -236,8 +299,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	artifact := &Artifact{
 		snapshotName: state.Get("snapshot_name").(string),
 		snapshotId:   state.Get("snapshot_image_id").(uint),
-		regionId:     region_id,
-		regionName:   regionName,
+		regionName:   found_region.Name,
 		client:       client,
 	}
 
diff --git a/builder/digitalocean/builder_test.go b/builder/digitalocean/builder_test.go
index 751cd1301..d6857bbe6 100644
--- a/builder/digitalocean/builder_test.go
+++ b/builder/digitalocean/builder_test.go
@@ -142,7 +142,7 @@ func TestBuilderPrepare_InvalidKey(t *testing.T) {
 	}
 }
 
-func TestBuilderPrepare_RegionID(t *testing.T) {
+func TestBuilderPrepare_Region(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
@@ -155,12 +155,15 @@ func TestBuilderPrepare_RegionID(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.RegionID != 1 {
-		t.Errorf("invalid: %d", b.config.RegionID)
+	if b.config.Region != DefaultRegion {
+		t.Errorf("found %s, expected %s", b.config.Region, DefaultRegion)
 	}
 
+	expected := "sfo1"
+
 	// Test set
-	config["region_id"] = 2
+	config["region_id"] = 0
+	config["region"] = expected
 	b = Builder{}
 	warnings, err = b.Prepare(config)
 	if len(warnings) > 0 {
@@ -170,12 +173,12 @@ func TestBuilderPrepare_RegionID(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.RegionID != 2 {
-		t.Errorf("invalid: %d", b.config.RegionID)
+	if b.config.Region != expected {
+		t.Errorf("found %s, expected %s", b.config.Region, expected)
 	}
 }
 
-func TestBuilderPrepare_SizeID(t *testing.T) {
+func TestBuilderPrepare_Size(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
@@ -188,12 +191,15 @@ func TestBuilderPrepare_SizeID(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.SizeID != 66 {
-		t.Errorf("invalid: %d", b.config.SizeID)
+	if b.config.Size != DefaultSize {
+		t.Errorf("found %s, expected %s", b.config.Size, DefaultSize)
 	}
 
+	expected := "1024mb"
+
 	// Test set
-	config["size_id"] = 67
+	config["size_id"] = 0
+	config["size"] = expected
 	b = Builder{}
 	warnings, err = b.Prepare(config)
 	if len(warnings) > 0 {
@@ -203,12 +209,12 @@ func TestBuilderPrepare_SizeID(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.SizeID != 67 {
-		t.Errorf("invalid: %d", b.config.SizeID)
+	if b.config.Size != expected {
+		t.Errorf("found %s, expected %s", b.config.Size, expected)
 	}
 }
 
-func TestBuilderPrepare_ImageID(t *testing.T) {
+func TestBuilderPrepare_Image(t *testing.T) {
 	var b Builder
 	config := testConfig()
 
@@ -221,12 +227,15 @@ func TestBuilderPrepare_ImageID(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.SizeID != 66 {
-		t.Errorf("invalid: %d", b.config.SizeID)
+	if b.config.Image != DefaultImage {
+		t.Errorf("found %s, expected %s", b.config.Image, DefaultImage)
 	}
 
+	expected := "ubuntu-14-04-x64"
+
 	// Test set
-	config["size_id"] = 2
+	config["image_id"] = 0
+	config["image"] = expected
 	b = Builder{}
 	warnings, err = b.Prepare(config)
 	if len(warnings) > 0 {
@@ -236,8 +245,8 @@ func TestBuilderPrepare_ImageID(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.SizeID != 2 {
-		t.Errorf("invalid: %d", b.config.SizeID)
+	if b.config.Image != expected {
+		t.Errorf("found %s, expected %s", b.config.Image, expected)
 	}
 }
 
diff --git a/builder/digitalocean/step_create_droplet.go b/builder/digitalocean/step_create_droplet.go
index f46e7fd3c..85164abaf 100644
--- a/builder/digitalocean/step_create_droplet.go
+++ b/builder/digitalocean/step_create_droplet.go
@@ -2,6 +2,7 @@ package digitalocean
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 )
@@ -11,7 +12,7 @@ type stepCreateDroplet struct {
 }
 
 func (s *stepCreateDroplet) Run(state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 	c := state.Get("config").(config)
 	sshKeyId := state.Get("ssh_key_id").(uint)
@@ -19,7 +20,7 @@ func (s *stepCreateDroplet) Run(state multistep.StateBag) multistep.StepAction {
 	ui.Say("Creating droplet...")
 
 	// Create the droplet based on configuration
-	dropletId, err := client.CreateDroplet(c.DropletName, c.SizeID, c.ImageID, c.RegionID, sshKeyId, c.PrivateNetworking)
+	dropletId, err := client.CreateDroplet(c.DropletName, c.Size, c.Image, c.Region, sshKeyId, c.PrivateNetworking)
 
 	if err != nil {
 		err := fmt.Errorf("Error creating droplet: %s", err)
@@ -43,7 +44,7 @@ func (s *stepCreateDroplet) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 	c := state.Get("config").(config)
 
@@ -53,7 +54,7 @@ func (s *stepCreateDroplet) Cleanup(state multistep.StateBag) {
 	err := client.DestroyDroplet(s.dropletId)
 	if err != nil {
 		curlstr := fmt.Sprintf("curl '%v/droplets/%v/destroy?client_id=%v&api_key=%v'",
-			DIGITALOCEAN_API_URL, s.dropletId, c.ClientID, c.APIKey)
+			c.APIURL, s.dropletId, c.ClientID, c.APIKey)
 
 		ui.Error(fmt.Sprintf(
 			"Error destroying droplet. Please destroy it manually: %v", curlstr))
diff --git a/builder/digitalocean/step_create_ssh_key.go b/builder/digitalocean/step_create_ssh_key.go
index e686b1ec7..78bb474c1 100644
--- a/builder/digitalocean/step_create_ssh_key.go
+++ b/builder/digitalocean/step_create_ssh_key.go
@@ -1,16 +1,17 @@
 package digitalocean
 
 import (
-	"code.google.com/p/gosshold/ssh"
 	"crypto/rand"
 	"crypto/rsa"
 	"crypto/x509"
 	"encoding/pem"
 	"fmt"
+	"log"
+
+	"code.google.com/p/gosshold/ssh"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
-	"log"
 )
 
 type stepCreateSSHKey struct {
@@ -18,7 +19,7 @@ type stepCreateSSHKey struct {
 }
 
 func (s *stepCreateSSHKey) Run(state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say("Creating temporary ssh key for droplet...")
@@ -70,15 +71,14 @@ func (s *stepCreateSSHKey) Cleanup(state multistep.StateBag) {
 		return
 	}
 
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 	c := state.Get("config").(config)
 
 	ui.Say("Deleting temporary ssh key...")
 	err := client.DestroyKey(s.keyId)
 
-	curlstr := fmt.Sprintf("curl '%v/ssh_keys/%v/destroy?client_id=%v&api_key=%v'",
-		DIGITALOCEAN_API_URL, s.keyId, c.ClientID, c.APIKey)
+	curlstr := fmt.Sprintf("curl -H 'Authorization: Bearer #TOKEN#' -X DELETE '%v/v2/account/keys/%v'", c.APIURL, s.keyId)
 
 	if err != nil {
 		log.Printf("Error cleaning up ssh key: %v", err.Error())
diff --git a/builder/digitalocean/step_droplet_info.go b/builder/digitalocean/step_droplet_info.go
index b9350c531..ea08599ce 100644
--- a/builder/digitalocean/step_droplet_info.go
+++ b/builder/digitalocean/step_droplet_info.go
@@ -2,6 +2,7 @@ package digitalocean
 
 import (
 	"fmt"
+
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
 )
@@ -9,7 +10,7 @@ import (
 type stepDropletInfo struct{}
 
 func (s *stepDropletInfo) Run(state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 	c := state.Get("config").(config)
 	dropletId := state.Get("droplet_id").(uint)
diff --git a/builder/digitalocean/step_power_off.go b/builder/digitalocean/step_power_off.go
index 9aa5e30b8..efead2d8a 100644
--- a/builder/digitalocean/step_power_off.go
+++ b/builder/digitalocean/step_power_off.go
@@ -2,15 +2,16 @@ package digitalocean
 
 import (
 	"fmt"
+	"log"
+
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"log"
 )
 
 type stepPowerOff struct{}
 
 func (s *stepPowerOff) Run(state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	c := state.Get("config").(config)
 	ui := state.Get("ui").(packer.Ui)
 	dropletId := state.Get("droplet_id").(uint)
diff --git a/builder/digitalocean/step_shutdown.go b/builder/digitalocean/step_shutdown.go
index fc36dbad4..06a2ae9f5 100644
--- a/builder/digitalocean/step_shutdown.go
+++ b/builder/digitalocean/step_shutdown.go
@@ -2,16 +2,17 @@ package digitalocean
 
 import (
 	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"time"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 type stepShutdown struct{}
 
 func (s *stepShutdown) Run(state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 	dropletId := state.Get("droplet_id").(uint)
 
diff --git a/builder/digitalocean/step_snapshot.go b/builder/digitalocean/step_snapshot.go
index b8ae66062..4fdf20bc1 100644
--- a/builder/digitalocean/step_snapshot.go
+++ b/builder/digitalocean/step_snapshot.go
@@ -3,15 +3,16 @@ package digitalocean
 import (
 	"errors"
 	"fmt"
+	"log"
+
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"log"
 )
 
 type stepSnapshot struct{}
 
 func (s *stepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
-	client := state.Get("client").(*DigitalOceanClient)
+	client := state.Get("client").(DigitalOceanClient)
 	ui := state.Get("ui").(packer.Ui)
 	c := state.Get("config").(config)
 	dropletId := state.Get("droplet_id").(uint)
@@ -62,7 +63,7 @@ func (s *stepSnapshot) Run(state multistep.StateBag) multistep.StepAction {
 
 	state.Put("snapshot_image_id", imageId)
 	state.Put("snapshot_name", c.SnapshotName)
-	state.Put("region_id", c.RegionID)
+	state.Put("region", c.Region)
 
 	return multistep.ActionContinue
 }
diff --git a/builder/digitalocean/wait.go b/builder/digitalocean/wait.go
index a0104c60d..e5b1dee90 100644
--- a/builder/digitalocean/wait.go
+++ b/builder/digitalocean/wait.go
@@ -8,7 +8,7 @@ import (
 
 // waitForState simply blocks until the droplet is in
 // a state we expect, while eventually timing out.
-func waitForDropletState(desiredState string, dropletId uint, client *DigitalOceanClient, timeout time.Duration) error {
+func waitForDropletState(desiredState string, dropletId uint, client DigitalOceanClient, timeout time.Duration) error {
 	done := make(chan struct{})
 	defer close(done)
 
diff --git a/builder/docker/artifact_export.go b/builder/docker/artifact_export.go
index 29cbefb48..d9eb83f67 100644
--- a/builder/docker/artifact_export.go
+++ b/builder/docker/artifact_export.go
@@ -27,6 +27,10 @@ func (a *ExportArtifact) String() string {
 	return fmt.Sprintf("Exported Docker file: %s", a.path)
 }
 
+func (a *ExportArtifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *ExportArtifact) Destroy() error {
 	return os.Remove(a.path)
 }
diff --git a/builder/docker/artifact_import.go b/builder/docker/artifact_import.go
index 4c926eb53..6ab0fe482 100644
--- a/builder/docker/artifact_import.go
+++ b/builder/docker/artifact_import.go
@@ -28,6 +28,10 @@ func (a *ImportArtifact) String() string {
 	return fmt.Sprintf("Imported Docker image: %s", a.Id())
 }
 
+func (*ImportArtifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *ImportArtifact) Destroy() error {
 	return a.Driver.DeleteImage(a.Id())
 }
diff --git a/builder/docker/builder.go b/builder/docker/builder.go
index f8c3832e9..6ab6fb593 100644
--- a/builder/docker/builder.go
+++ b/builder/docker/builder.go
@@ -8,6 +8,7 @@ import (
 )
 
 const BuilderId = "packer.docker"
+const BuilderIdImport = "packer.post-processor.docker-import"
 
 type Builder struct {
 	config *Config
@@ -35,7 +36,12 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&StepPull{},
 		&StepRun{},
 		&StepProvision{},
-		&StepExport{},
+	}
+
+	if b.config.Commit {
+		steps = append(steps, new(StepCommit))
+	} else {
+		steps = append(steps, new(StepExport))
 	}
 
 	// Setup the state bag and initial state for the steps
@@ -64,8 +70,17 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		return nil, rawErr.(error)
 	}
 
+	var artifact packer.Artifact
 	// No errors, must've worked
-	artifact := &ExportArtifact{path: b.config.ExportPath}
+	if b.config.Commit {
+		artifact = &ImportArtifact{
+			IdValue:        state.Get("image_id").(string),
+			BuilderIdValue: BuilderIdImport,
+			Driver:         driver,
+		}
+	} else {
+		artifact = &ExportArtifact{path: b.config.ExportPath}
+	}
 	return artifact, nil
 }
 
diff --git a/builder/docker/communicator.go b/builder/docker/communicator.go
index 649a135f5..d5f0eb713 100644
--- a/builder/docker/communicator.go
+++ b/builder/docker/communicator.go
@@ -3,8 +3,6 @@ package docker
 import (
 	"bytes"
 	"fmt"
-	"github.com/ActiveState/tail"
-	"github.com/mitchellh/packer/packer"
 	"io"
 	"io/ioutil"
 	"log"
@@ -15,6 +13,9 @@ import (
 	"sync"
 	"syscall"
 	"time"
+
+	"github.com/ActiveState/tail"
+	"github.com/mitchellh/packer/packer"
 )
 
 type Communicator struct {
@@ -56,7 +57,7 @@ func (c *Communicator) Start(remote *packer.RemoteCmd) error {
 	return nil
 }
 
-func (c *Communicator) Upload(dst string, src io.Reader) error {
+func (c *Communicator) Upload(dst string, src io.Reader, fi *os.FileInfo) error {
 	// Create a temporary file to store the upload
 	tempfile, err := ioutil.TempFile(c.HostDir, "upload")
 	if err != nil {
@@ -231,20 +232,42 @@ func (c *Communicator) run(cmd *exec.Cmd, remote *packer.RemoteCmd, stdin_w io.W
 		stdin_w.Write([]byte(remoteCmd + "\n"))
 	}()
 
-	// Start a goroutine to read all the lines out of the logs
+	// Start a goroutine to read all the lines out of the logs. These channels
+	// allow us to stop the go-routine and wait for it to be stopped.
+	stopTailCh := make(chan struct{})
+	doneCh := make(chan struct{})
 	go func() {
-		for line := range tail.Lines {
-			if remote.Stdout != nil {
-				remote.Stdout.Write([]byte(line.Text + "\n"))
-			} else {
-				log.Printf("Command stdout: %#v", line.Text)
+		defer close(doneCh)
+
+		for {
+			select {
+			case <-tail.Dead():
+				return
+			case line := <-tail.Lines:
+				if remote.Stdout != nil {
+					remote.Stdout.Write([]byte(line.Text + "\n"))
+				} else {
+					log.Printf("Command stdout: %#v", line.Text)
+				}
+			case <-time.After(2 * time.Second):
+				// If we're done, then return. Otherwise, keep grabbing
+				// data. This gives us a chance to flush all the lines
+				// out of the tailed file.
+				select {
+				case <-stopTailCh:
+					return
+				default:
+				}
 			}
 		}
 	}()
 
+	var exitRaw []byte
+	var exitStatus int
+	var exitStatusRaw int64
 	err = cmd.Wait()
 	if exitErr, ok := err.(*exec.ExitError); ok {
-		exitStatus := 1
+		exitStatus = 1
 
 		// There is no process-independent way to get the REAL
 		// exit status so we just try to go deeper.
@@ -254,8 +277,7 @@ func (c *Communicator) run(cmd *exec.Cmd, remote *packer.RemoteCmd, stdin_w io.W
 
 		// Say that we ended, since if Docker itself failed, then
 		// the command must've not run, or so we assume
-		remote.SetExited(exitStatus)
-		return
+		goto REMOTE_EXIT
 	}
 
 	// Wait for the exit code to appear in our file...
@@ -270,21 +292,27 @@ func (c *Communicator) run(cmd *exec.Cmd, remote *packer.RemoteCmd, stdin_w io.W
 	}
 
 	// Read the exit code
-	exitRaw, err := ioutil.ReadFile(exitCodePath)
+	exitRaw, err = ioutil.ReadFile(exitCodePath)
 	if err != nil {
 		log.Printf("Error executing: %s", err)
-		remote.SetExited(254)
-		return
+		exitStatus = 254
+		goto REMOTE_EXIT
 	}
 
-	exitStatus, err := strconv.ParseInt(string(bytes.TrimSpace(exitRaw)), 10, 0)
+	exitStatusRaw, err = strconv.ParseInt(string(bytes.TrimSpace(exitRaw)), 10, 0)
 	if err != nil {
 		log.Printf("Error executing: %s", err)
-		remote.SetExited(254)
-		return
+		exitStatus = 254
+		goto REMOTE_EXIT
 	}
+	exitStatus = int(exitStatusRaw)
 	log.Printf("Executed command exit status: %d", exitStatus)
 
-	// Finally, we're done
-	remote.SetExited(int(exitStatus))
+REMOTE_EXIT:
+	// Wait for the tail to finish
+	close(stopTailCh)
+	<-doneCh
+
+	// Set the exit status which triggers waiters
+	remote.SetExited(exitStatus)
 }
diff --git a/builder/docker/config.go b/builder/docker/config.go
index 045bf19b8..dda726225 100644
--- a/builder/docker/config.go
+++ b/builder/docker/config.go
@@ -9,10 +9,18 @@ import (
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
+	Commit     bool
 	ExportPath string `mapstructure:"export_path"`
 	Image      string
 	Pull       bool
 	RunCommand []string `mapstructure:"run_command"`
+	Volumes    map[string]string
+
+	Login         bool
+	LoginEmail    string `mapstructure:"login_email"`
+	LoginUsername string `mapstructure:"login_username"`
+	LoginPassword string `mapstructure:"login_password"`
+	LoginServer   string `mapstructure:"login_server"`
 
 	tpl *packer.ConfigTemplate
 }
@@ -34,9 +42,7 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	// Defaults
 	if len(c.RunCommand) == 0 {
 		c.RunCommand = []string{
-			"run",
 			"-d", "-i", "-t",
-			"-v", "{{.Volumes}}",
 			"{{.Image}}",
 			"/bin/bash",
 		}
@@ -58,8 +64,12 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	errs := common.CheckUnusedConfig(md)
 
 	templates := map[string]*string{
-		"export_path": &c.ExportPath,
-		"image":       &c.Image,
+		"export_path":    &c.ExportPath,
+		"image":          &c.Image,
+		"login_email":    &c.LoginEmail,
+		"login_username": &c.LoginUsername,
+		"login_password": &c.LoginPassword,
+		"login_server":   &c.LoginServer,
 	}
 
 	for n, ptr := range templates {
@@ -71,9 +81,15 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		}
 	}
 
-	if c.ExportPath == "" {
-		errs = packer.MultiErrorAppend(errs,
-			fmt.Errorf("export_path must be specified"))
+	for k, v := range c.Volumes {
+		var err error
+		v, err = c.tpl.Process(v, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing volumes[%s]: %s", k, err))
+		}
+
+		c.Volumes[k] = v
 	}
 
 	if c.Image == "" {
@@ -81,6 +97,11 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 			fmt.Errorf("image must be specified"))
 	}
 
+	if c.ExportPath != "" && c.Commit {
+		errs = packer.MultiErrorAppend(errs,
+			fmt.Errorf("both commit and export_path cannot be set"))
+	}
+
 	if errs != nil && len(errs.Errors) > 0 {
 		return nil, nil, errs
 	}
diff --git a/builder/docker/config_test.go b/builder/docker/config_test.go
index 3b279ab22..3f535b9e9 100644
--- a/builder/docker/config_test.go
+++ b/builder/docker/config_test.go
@@ -47,7 +47,7 @@ func TestConfigPrepare_exportPath(t *testing.T) {
 	// No export path
 	delete(raw, "export_path")
 	_, warns, errs := NewConfig(raw)
-	testConfigErr(t, warns, errs)
+	testConfigOk(t, warns, errs)
 
 	// Good export path
 	raw["export_path"] = "good"
@@ -55,6 +55,20 @@ func TestConfigPrepare_exportPath(t *testing.T) {
 	testConfigOk(t, warns, errs)
 }
 
+func TestConfigPrepare_exportPathAndCommit(t *testing.T) {
+	raw := testConfig()
+	raw["commit"] = true
+
+	// No export path
+	_, warns, errs := NewConfig(raw)
+	testConfigErr(t, warns, errs)
+
+	// No commit
+	raw["commit"] = false
+	_, warns, errs = NewConfig(raw)
+	testConfigOk(t, warns, errs)
+}
+
 func TestConfigPrepare_image(t *testing.T) {
 	raw := testConfig()
 
diff --git a/builder/docker/driver.go b/builder/docker/driver.go
index aaed2fc52..85b87b1d0 100644
--- a/builder/docker/driver.go
+++ b/builder/docker/driver.go
@@ -8,6 +8,9 @@ import (
 // Docker. The Driver interface also allows the steps to be tested since
 // a mock driver can be shimmed in.
 type Driver interface {
+	// Commit the container to a tag
+	Commit(id string) (string, error)
+
 	// Delete an image that is imported into Docker
 	DeleteImage(id string) error
 
@@ -17,12 +20,22 @@ type Driver interface {
 	// Import imports a container from a tar file
 	Import(path, repo string) (string, error)
 
+	// Login. This will lock the driver from performing another Login
+	// until Logout is called. Therefore, any users MUST call Logout.
+	Login(repo, email, username, password string) error
+
+	// Logout. This can only be called if Login succeeded.
+	Logout(repo string) error
+
 	// Pull should pull down the given image.
 	Pull(image string) error
 
 	// Push pushes an image to a Docker index/registry.
 	Push(name string) error
 
+	// Save an image with the given ID to the given writer.
+	SaveImage(id string, dst io.Writer) error
+
 	// StartContainer starts a container and returns the ID for that container,
 	// along with a potential error.
 	StartContainer(*ContainerConfig) (string, error)
@@ -30,6 +43,9 @@ type Driver interface {
 	// StopContainer forcibly stops a container.
 	StopContainer(id string) error
 
+	// TagImage tags the image with the given ID
+	TagImage(id string, repo string) error
+
 	// Verify verifies that the driver can run
 	Verify() error
 }
@@ -43,6 +59,5 @@ type ContainerConfig struct {
 
 // This is the template that is used for the RunCommand in the ContainerConfig.
 type startContainerTemplate struct {
-	Image   string
-	Volumes string
+	Image string
 }
diff --git a/builder/docker/driver_docker.go b/builder/docker/driver_docker.go
index 5c43e0078..f724e37ec 100644
--- a/builder/docker/driver_docker.go
+++ b/builder/docker/driver_docker.go
@@ -3,17 +3,21 @@ package docker
 import (
 	"bytes"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
 	"io"
 	"log"
 	"os"
 	"os/exec"
 	"strings"
+	"sync"
+
+	"github.com/mitchellh/packer/packer"
 )
 
 type DockerDriver struct {
 	Ui  packer.Ui
 	Tpl *packer.ConfigTemplate
+
+	l sync.Mutex
 }
 
 func (d *DockerDriver) DeleteImage(id string) error {
@@ -35,6 +39,27 @@ func (d *DockerDriver) DeleteImage(id string) error {
 	return nil
 }
 
+func (d *DockerDriver) Commit(id string) (string, error) {
+	var stdout bytes.Buffer
+	var stderr bytes.Buffer
+
+	cmd := exec.Command("docker", "commit", id)
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+
+	if err := cmd.Start(); err != nil {
+		return "", err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		err = fmt.Errorf("Error committing container: %s\nStderr: %s",
+			err, stderr.String())
+		return "", err
+	}
+
+	return strings.TrimSpace(stdout.String()), nil
+}
+
 func (d *DockerDriver) Export(id string, dst io.Writer) error {
 	var stderr bytes.Buffer
 	cmd := exec.Command("docker", "export", id)
@@ -88,6 +113,44 @@ func (d *DockerDriver) Import(path string, repo string) (string, error) {
 	return strings.TrimSpace(stdout.String()), nil
 }
 
+func (d *DockerDriver) Login(repo, email, user, pass string) error {
+	d.l.Lock()
+
+	args := []string{"login"}
+	if email != "" {
+		args = append(args, "-e", email)
+	}
+	if user != "" {
+		args = append(args, "-u", user)
+	}
+	if pass != "" {
+		args = append(args, "-p", pass)
+	}
+	if repo != "" {
+		args = append(args, repo)
+	}
+
+	cmd := exec.Command("docker", args...)
+	err := runAndStream(cmd, d.Ui)
+	if err != nil {
+		d.l.Unlock()
+	}
+
+	return err
+}
+
+func (d *DockerDriver) Logout(repo string) error {
+	args := []string{"logout"}
+	if repo != "" {
+		args = append(args, repo)
+	}
+
+	cmd := exec.Command("docker", args...)
+	err := runAndStream(cmd, d.Ui)
+	d.l.Unlock()
+	return err
+}
+
 func (d *DockerDriver) Pull(image string) error {
 	cmd := exec.Command("docker", "pull", image)
 	return runAndStream(cmd, d.Ui)
@@ -98,27 +161,43 @@ func (d *DockerDriver) Push(name string) error {
 	return runAndStream(cmd, d.Ui)
 }
 
+func (d *DockerDriver) SaveImage(id string, dst io.Writer) error {
+	var stderr bytes.Buffer
+	cmd := exec.Command("docker", "save", id)
+	cmd.Stdout = dst
+	cmd.Stderr = &stderr
+
+	log.Printf("Exporting image: %s", id)
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		err = fmt.Errorf("Error exporting: %s\nStderr: %s",
+			err, stderr.String())
+		return err
+	}
+
+	return nil
+}
+
 func (d *DockerDriver) StartContainer(config *ContainerConfig) (string, error) {
 	// Build up the template data
 	var tplData startContainerTemplate
 	tplData.Image = config.Image
-	if len(config.Volumes) > 0 {
-		volumes := make([]string, 0, len(config.Volumes))
-		for host, guest := range config.Volumes {
-			volumes = append(volumes, fmt.Sprintf("%s:%s", host, guest))
-		}
-
-		tplData.Volumes = strings.Join(volumes, ",")
-	}
 
 	// Args that we're going to pass to Docker
-	args := config.RunCommand
-	for i, v := range args {
-		var err error
-		args[i], err = d.Tpl.Process(v, &tplData)
+	args := []string{"run"}
+	for host, guest := range config.Volumes {
+		args = append(args, "-v", fmt.Sprintf("%s:%s", host, guest))
+	}
+	for _, v := range config.RunCommand {
+		v, err := d.Tpl.Process(v, &tplData)
 		if err != nil {
 			return "", err
 		}
+
+		args = append(args, v)
 	}
 	d.Ui.Message(fmt.Sprintf(
 		"Run command: docker %s", strings.Join(args, " ")))
@@ -149,7 +228,29 @@ func (d *DockerDriver) StartContainer(config *ContainerConfig) (string, error) {
 }
 
 func (d *DockerDriver) StopContainer(id string) error {
-	return exec.Command("docker", "kill", id).Run()
+	if err := exec.Command("docker", "kill", id).Run(); err != nil {
+		return err
+	}
+
+	return exec.Command("docker", "rm", id).Run()
+}
+
+func (d *DockerDriver) TagImage(id string, repo string) error {
+	var stderr bytes.Buffer
+	cmd := exec.Command("docker", "tag", id, repo)
+	cmd.Stderr = &stderr
+
+	if err := cmd.Start(); err != nil {
+		return err
+	}
+
+	if err := cmd.Wait(); err != nil {
+		err = fmt.Errorf("Error tagging image: %s\nStderr: %s",
+			err, stderr.String())
+		return err
+	}
+
+	return nil
 }
 
 func (d *DockerDriver) Verify() error {
diff --git a/builder/docker/driver_mock.go b/builder/docker/driver_mock.go
index a48bb99f8..549e79611 100644
--- a/builder/docker/driver_mock.go
+++ b/builder/docker/driver_mock.go
@@ -6,6 +6,11 @@ import (
 
 // MockDriver is a driver implementation that can be used for tests.
 type MockDriver struct {
+	CommitCalled      bool
+	CommitContainerId string
+	CommitImageId     string
+	CommitErr         error
+
 	DeleteImageCalled bool
 	DeleteImageId     string
 	DeleteImageErr    error
@@ -16,10 +21,31 @@ type MockDriver struct {
 	ImportId     string
 	ImportErr    error
 
+	LoginCalled   bool
+	LoginEmail    string
+	LoginUsername string
+	LoginPassword string
+	LoginRepo     string
+	LoginErr      error
+
+	LogoutCalled bool
+	LogoutRepo   string
+	LogoutErr    error
+
 	PushCalled bool
 	PushName   string
 	PushErr    error
 
+	SaveImageCalled bool
+	SaveImageId     string
+	SaveImageReader io.Reader
+	SaveImageError  error
+
+	TagImageCalled  bool
+	TagImageImageId string
+	TagImageRepo    string
+	TagImageErr     error
+
 	ExportReader io.Reader
 	ExportError  error
 	PullError    error
@@ -39,6 +65,12 @@ type MockDriver struct {
 	VerifyCalled bool
 }
 
+func (d *MockDriver) Commit(id string) (string, error) {
+	d.CommitCalled = true
+	d.CommitContainerId = id
+	return d.CommitImageId, d.CommitErr
+}
+
 func (d *MockDriver) DeleteImage(id string) error {
 	d.DeleteImageCalled = true
 	d.DeleteImageId = id
@@ -66,6 +98,21 @@ func (d *MockDriver) Import(path, repo string) (string, error) {
 	return d.ImportId, d.ImportErr
 }
 
+func (d *MockDriver) Login(r, e, u, p string) error {
+	d.LoginCalled = true
+	d.LoginRepo = r
+	d.LoginEmail = e
+	d.LoginUsername = u
+	d.LoginPassword = p
+	return d.LoginErr
+}
+
+func (d *MockDriver) Logout(r string) error {
+	d.LogoutCalled = true
+	d.LogoutRepo = r
+	return d.LogoutErr
+}
+
 func (d *MockDriver) Pull(image string) error {
 	d.PullCalled = true
 	d.PullImage = image
@@ -78,6 +125,20 @@ func (d *MockDriver) Push(name string) error {
 	return d.PushErr
 }
 
+func (d *MockDriver) SaveImage(id string, dst io.Writer) error {
+	d.SaveImageCalled = true
+	d.SaveImageId = id
+
+	if d.SaveImageReader != nil {
+		_, err := io.Copy(dst, d.SaveImageReader)
+		if err != nil {
+			return err
+		}
+	}
+
+	return d.SaveImageError
+}
+
 func (d *MockDriver) StartContainer(config *ContainerConfig) (string, error) {
 	d.StartCalled = true
 	d.StartConfig = config
@@ -90,6 +151,13 @@ func (d *MockDriver) StopContainer(id string) error {
 	return d.StopError
 }
 
+func (d *MockDriver) TagImage(id string, repo string) error {
+	d.TagImageCalled = true
+	d.TagImageImageId = id
+	d.TagImageRepo = repo
+	return d.TagImageErr
+}
+
 func (d *MockDriver) Verify() error {
 	d.VerifyCalled = true
 	return d.VerifyError
diff --git a/builder/docker/step_commit.go b/builder/docker/step_commit.go
new file mode 100644
index 000000000..bd1277182
--- /dev/null
+++ b/builder/docker/step_commit.go
@@ -0,0 +1,35 @@
+package docker
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+// StepCommit commits the container to a image.
+type StepCommit struct {
+	imageId string
+}
+
+func (s *StepCommit) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
+	containerId := state.Get("container_id").(string)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Committing the container")
+	imageId, err := driver.Commit(containerId)
+	if err != nil {
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Save the container ID
+	s.imageId = imageId
+	state.Put("image_id", s.imageId)
+	ui.Message(fmt.Sprintf("Image ID: %s", s.imageId))
+
+	return multistep.ActionContinue
+}
+
+func (s *StepCommit) Cleanup(state multistep.StateBag) {}
diff --git a/builder/docker/step_commit_test.go b/builder/docker/step_commit_test.go
new file mode 100644
index 000000000..29e583f81
--- /dev/null
+++ b/builder/docker/step_commit_test.go
@@ -0,0 +1,66 @@
+package docker
+
+import (
+	"errors"
+	"github.com/mitchellh/multistep"
+	"testing"
+)
+
+func testStepCommitState(t *testing.T) multistep.StateBag {
+	state := testState(t)
+	state.Put("container_id", "foo")
+	return state
+}
+
+func TestStepCommit_impl(t *testing.T) {
+	var _ multistep.Step = new(StepCommit)
+}
+
+func TestStepCommit(t *testing.T) {
+	state := testStepCommitState(t)
+	step := new(StepCommit)
+	defer step.Cleanup(state)
+
+	driver := state.Get("driver").(*MockDriver)
+	driver.CommitImageId = "bar"
+
+	// run the step
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+
+	// verify we did the right thing
+	if !driver.CommitCalled {
+		t.Fatal("should've called")
+	}
+
+	// verify the ID is saved
+	idRaw, ok := state.GetOk("image_id")
+	if !ok {
+		t.Fatal("should've saved ID")
+	}
+
+	id := idRaw.(string)
+	if id != driver.CommitImageId {
+		t.Fatalf("bad: %#v", id)
+	}
+}
+
+func TestStepCommit_error(t *testing.T) {
+	state := testStepCommitState(t)
+	step := new(StepCommit)
+	defer step.Cleanup(state)
+
+	driver := state.Get("driver").(*MockDriver)
+	driver.CommitErr = errors.New("foo")
+
+	// run the step
+	if action := step.Run(state); action != multistep.ActionHalt {
+		t.Fatalf("bad action: %#v", action)
+	}
+
+	// verify the ID is not saved
+	if _, ok := state.GetOk("image_id"); ok {
+		t.Fatal("shouldn't save image ID")
+	}
+}
diff --git a/builder/docker/step_export.go b/builder/docker/step_export.go
index 69d6f483c..aa949b610 100644
--- a/builder/docker/step_export.go
+++ b/builder/docker/step_export.go
@@ -12,6 +12,7 @@ type StepExport struct{}
 
 func (s *StepExport) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
+
 	driver := state.Get("driver").(Driver)
 	containerId := state.Get("container_id").(string)
 	ui := state.Get("ui").(packer.Ui)
diff --git a/builder/docker/step_pull.go b/builder/docker/step_pull.go
index 6571a6563..346334e1e 100644
--- a/builder/docker/step_pull.go
+++ b/builder/docker/step_pull.go
@@ -20,6 +20,29 @@ func (s *StepPull) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	ui.Say(fmt.Sprintf("Pulling Docker image: %s", config.Image))
+
+	if config.Login {
+		ui.Message("Logging in...")
+		err := driver.Login(
+			config.LoginServer,
+			config.LoginEmail,
+			config.LoginUsername,
+			config.LoginPassword)
+		if err != nil {
+			err := fmt.Errorf("Error logging in: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		defer func() {
+			ui.Message("Logging out...")
+			if err := driver.Logout(config.LoginServer); err != nil {
+				ui.Error(fmt.Sprintf("Error logging out: %s", err))
+			}
+		}()
+	}
+
 	if err := driver.Pull(config.Image); err != nil {
 		err := fmt.Errorf("Error pulling Docker image: %s", err)
 		state.Put("error", err)
diff --git a/builder/docker/step_pull_test.go b/builder/docker/step_pull_test.go
index 5c66425bb..7ba5705d5 100644
--- a/builder/docker/step_pull_test.go
+++ b/builder/docker/step_pull_test.go
@@ -51,6 +51,35 @@ func TestStepPull_error(t *testing.T) {
 	}
 }
 
+func TestStepPull_login(t *testing.T) {
+	state := testState(t)
+	step := new(StepPull)
+	defer step.Cleanup(state)
+
+	config := state.Get("config").(*Config)
+	driver := state.Get("driver").(*MockDriver)
+
+	config.Login = true
+
+	// run the step
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+
+	// verify we pulled
+	if !driver.PullCalled {
+		t.Fatal("should've pulled")
+	}
+
+	// verify we logged in
+	if !driver.LoginCalled {
+		t.Fatal("should've logged in")
+	}
+	if !driver.LogoutCalled {
+		t.Fatal("should've logged out")
+	}
+}
+
 func TestStepPull_noPull(t *testing.T) {
 	state := testState(t)
 	step := new(StepPull)
diff --git a/builder/docker/step_run.go b/builder/docker/step_run.go
index 97ec8c4cb..7a46ce0e3 100644
--- a/builder/docker/step_run.go
+++ b/builder/docker/step_run.go
@@ -19,11 +19,14 @@ func (s *StepRun) Run(state multistep.StateBag) multistep.StepAction {
 	runConfig := ContainerConfig{
 		Image:      config.Image,
 		RunCommand: config.RunCommand,
-		Volumes: map[string]string{
-			tempDir: "/packer-files",
-		},
+		Volumes:    make(map[string]string),
 	}
 
+	for host, container := range config.Volumes {
+		runConfig.Volumes[host] = container
+	}
+	runConfig.Volumes[tempDir] = "/packer-files"
+
 	ui.Say("Starting docker container...")
 	containerId, err := driver.StartContainer(&runConfig)
 	if err != nil {
diff --git a/builder/googlecompute/account.go b/builder/googlecompute/account.go
new file mode 100644
index 000000000..59baf6044
--- /dev/null
+++ b/builder/googlecompute/account.go
@@ -0,0 +1,25 @@
+package googlecompute
+
+import (
+	"encoding/json"
+	"os"
+)
+
+// accountFile represents the structure of the account file JSON file.
+type accountFile struct {
+	PrivateKeyId string `json:"private_key_id"`
+	PrivateKey   string `json:"private_key"`
+	ClientEmail  string `json:"client_email"`
+	ClientId     string `json:"client_id"`
+}
+
+func loadJSON(result interface{}, path string) error {
+	f, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+
+	dec := json.NewDecoder(f)
+	return dec.Decode(result)
+}
diff --git a/builder/googlecompute/artifact.go b/builder/googlecompute/artifact.go
index a09946f9f..cb2ad88bb 100644
--- a/builder/googlecompute/artifact.go
+++ b/builder/googlecompute/artifact.go
@@ -37,3 +37,7 @@ func (a *Artifact) Id() string {
 func (a *Artifact) String() string {
 	return fmt.Sprintf("A disk image was created: %v", a.imageName)
 }
+
+func (a *Artifact) State(name string) interface{} {
+	return nil
+}
diff --git a/builder/googlecompute/builder.go b/builder/googlecompute/builder.go
index 6cd72ba11..4b0b32ca5 100644
--- a/builder/googlecompute/builder.go
+++ b/builder/googlecompute/builder.go
@@ -35,7 +35,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 // representing a GCE machine image.
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
 	driver, err := NewDriverGCE(
-		ui, b.config.ProjectId, b.config.clientSecrets, b.config.privateKeyBytes)
+		ui, b.config.ProjectId, &b.config.account)
 	if err != nil {
 		return nil, err
 	}
@@ -65,7 +65,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			SSHWaitTimeout: 5 * time.Minute,
 		},
 		new(common.StepProvision),
-		new(StepUpdateGsutil),
+		new(StepUpdateGcloud),
 		new(StepCreateImage),
 		new(StepUploadImage),
 		new(StepRegisterImage),
diff --git a/builder/googlecompute/client_secrets.go b/builder/googlecompute/client_secrets.go
deleted file mode 100644
index cbe071514..000000000
--- a/builder/googlecompute/client_secrets.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package googlecompute
-
-import (
-	"encoding/json"
-	"io/ioutil"
-)
-
-// clientSecrets represents the client secrets of a GCE service account.
-type clientSecrets struct {
-	Web struct {
-		AuthURI     string `json:"auth_uri"`
-		ClientEmail string `json:"client_email"`
-		ClientId    string `json:"client_id"`
-		TokenURI    string `json:"token_uri"`
-	}
-}
-
-// loadClientSecrets loads the GCE client secrets file identified by path.
-func loadClientSecrets(path string) (*clientSecrets, error) {
-	var cs *clientSecrets
-	secretBytes, err := ioutil.ReadFile(path)
-	if err != nil {
-		return nil, err
-	}
-
-	err = json.Unmarshal(secretBytes, &cs)
-	if err != nil {
-		return nil, err
-	}
-
-	return cs, nil
-}
diff --git a/builder/googlecompute/client_secrets_test.go b/builder/googlecompute/client_secrets_test.go
deleted file mode 100644
index 584aa0ce1..000000000
--- a/builder/googlecompute/client_secrets_test.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package googlecompute
-
-import (
-	"io/ioutil"
-	"testing"
-)
-
-func testClientSecretsFile(t *testing.T) string {
-	tf, err := ioutil.TempFile("", "packer")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	defer tf.Close()
-
-	if _, err := tf.Write([]byte(testClientSecretsContent)); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	return tf.Name()
-}
-
-func TestLoadClientSecrets(t *testing.T) {
-	_, err := loadClientSecrets(testClientSecretsFile(t))
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-// This is just some dummy data that doesn't actually work (it was revoked
-// a long time ago).
-const testClientSecretsContent = `{"web":{"auth_uri":"https://accounts.google.com/o/oauth2/auth","token_uri":"https://accounts.google.com/o/oauth2/token","client_email":"774313886706-eorlsj0r4eqkh5e7nvea5fuf59ifr873@developer.gserviceaccount.com","client_x509_cert_url":"https://www.googleapis.com/robot/v1/metadata/x509/774313886706-eorlsj0r4eqkh5e7nvea5fuf59ifr873@developer.gserviceaccount.com","client_id":"774313886706-eorlsj0r4eqkh5e7nvea5fuf59ifr873.apps.googleusercontent.com","auth_provider_x509_cert_url":"https://www.googleapis.com/oauth2/v1/certs"}}`
diff --git a/builder/googlecompute/config.go b/builder/googlecompute/config.go
index a47e628f5..5c3639402 100644
--- a/builder/googlecompute/config.go
+++ b/builder/googlecompute/config.go
@@ -16,26 +16,27 @@ import (
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
-	BucketName        string            `mapstructure:"bucket_name"`
-	ClientSecretsFile string            `mapstructure:"client_secrets_file"`
-	ImageName         string            `mapstructure:"image_name"`
-	ImageDescription  string            `mapstructure:"image_description"`
-	InstanceName      string            `mapstructure:"instance_name"`
-	MachineType       string            `mapstructure:"machine_type"`
-	Metadata          map[string]string `mapstructure:"metadata"`
-	Network           string            `mapstructure:"network"`
-	Passphrase        string            `mapstructure:"passphrase"`
-	PrivateKeyFile    string            `mapstructure:"private_key_file"`
-	ProjectId         string            `mapstructure:"project_id"`
-	SourceImage       string            `mapstructure:"source_image"`
-	SSHUsername       string            `mapstructure:"ssh_username"`
-	SSHPort           uint              `mapstructure:"ssh_port"`
-	RawSSHTimeout     string            `mapstructure:"ssh_timeout"`
-	RawStateTimeout   string            `mapstructure:"state_timeout"`
-	Tags              []string          `mapstructure:"tags"`
-	Zone              string            `mapstructure:"zone"`
+	AccountFile       string `mapstructure:"account_file"`
+	ProjectId         string `mapstructure:"project_id"`
 
-	clientSecrets   *clientSecrets
+	BucketName           string            `mapstructure:"bucket_name"`
+	DiskSizeGb           int64             `mapstructure:"disk_size"`
+	ImageName            string            `mapstructure:"image_name"`
+	ImageDescription     string            `mapstructure:"image_description"`
+	InstanceName         string            `mapstructure:"instance_name"`
+	MachineType          string            `mapstructure:"machine_type"`
+	Metadata             map[string]string `mapstructure:"metadata"`
+	Network              string            `mapstructure:"network"`
+	SourceImage          string            `mapstructure:"source_image"`
+	SourceImageProjectId string            `mapstructure:"source_image_project_id"`
+	SSHUsername          string            `mapstructure:"ssh_username"`
+	SSHPort              uint              `mapstructure:"ssh_port"`
+	RawSSHTimeout        string            `mapstructure:"ssh_timeout"`
+	RawStateTimeout      string            `mapstructure:"state_timeout"`
+	Tags                 []string          `mapstructure:"tags"`
+	Zone                 string            `mapstructure:"zone"`
+
+	account         accountFile
 	instanceName    string
 	privateKeyBytes []byte
 	sshTimeout      time.Duration
@@ -64,6 +65,10 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		c.Network = "default"
 	}
 
+	if c.DiskSizeGb == 0 {
+		c.DiskSizeGb = 10
+	}
+
 	if c.ImageDescription == "" {
 		c.ImageDescription = "Created by Packer"
 	}
@@ -98,21 +103,21 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 
 	// Process Templates
 	templates := map[string]*string{
-		"bucket_name":         &c.BucketName,
-		"client_secrets_file": &c.ClientSecretsFile,
-		"image_name":          &c.ImageName,
-		"image_description":   &c.ImageDescription,
-		"instance_name":       &c.InstanceName,
-		"machine_type":        &c.MachineType,
-		"network":             &c.Network,
-		"passphrase":          &c.Passphrase,
-		"private_key_file":    &c.PrivateKeyFile,
-		"project_id":          &c.ProjectId,
-		"source_image":        &c.SourceImage,
-		"ssh_username":        &c.SSHUsername,
-		"ssh_timeout":         &c.RawSSHTimeout,
-		"state_timeout":       &c.RawStateTimeout,
-		"zone":                &c.Zone,
+		"account_file":        &c.AccountFile,
+
+		"bucket_name":             &c.BucketName,
+		"image_name":              &c.ImageName,
+		"image_description":       &c.ImageDescription,
+		"instance_name":           &c.InstanceName,
+		"machine_type":            &c.MachineType,
+		"network":                 &c.Network,
+		"project_id":              &c.ProjectId,
+		"source_image":            &c.SourceImage,
+		"source_image_project_id": &c.SourceImageProjectId,
+		"ssh_username":            &c.SSHUsername,
+		"ssh_timeout":             &c.RawSSHTimeout,
+		"state_timeout":           &c.RawStateTimeout,
+		"zone":                    &c.Zone,
 	}
 
 	for n, ptr := range templates {
@@ -130,16 +135,6 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 			errs, errors.New("a bucket_name must be specified"))
 	}
 
-	if c.ClientSecretsFile == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a client_secrets_file must be specified"))
-	}
-
-	if c.PrivateKeyFile == "" {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("a private_key_file must be specified"))
-	}
-
 	if c.ProjectId == "" {
 		errs = packer.MultiErrorAppend(
 			errs, errors.New("a project_id must be specified"))
@@ -170,22 +165,10 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	}
 	c.stateTimeout = stateTimeout
 
-	if c.ClientSecretsFile != "" {
-		// Load the client secrets file.
-		cs, err := loadClientSecrets(c.ClientSecretsFile)
-		if err != nil {
+	if c.AccountFile != "" {
+		if err := loadJSON(&c.account, c.AccountFile); err != nil {
 			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed parsing client secrets file: %s", err))
-		}
-		c.clientSecrets = cs
-	}
-
-	if c.PrivateKeyFile != "" {
-		// Load the private key.
-		c.privateKeyBytes, err = processPrivateKeyFile(c.PrivateKeyFile, c.Passphrase)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Failed loading private key file: %s", err))
+				errs, fmt.Errorf("Failed parsing account file: %s", err))
 		}
 	}
 
diff --git a/builder/googlecompute/config_test.go b/builder/googlecompute/config_test.go
index 6fa1425db..acc898ce7 100644
--- a/builder/googlecompute/config_test.go
+++ b/builder/googlecompute/config_test.go
@@ -1,14 +1,14 @@
 package googlecompute
 
 import (
+	"io/ioutil"
 	"testing"
 )
 
 func testConfig(t *testing.T) map[string]interface{} {
 	return map[string]interface{}{
+		"account_file":        testAccountFile(t),
 		"bucket_name":         "foo",
-		"client_secrets_file": testClientSecretsFile(t),
-		"private_key_file":    testPrivateKeyFile(t),
 		"project_id":          "hashicorp",
 		"source_image":        "foo",
 		"zone":                "us-east-1a",
@@ -68,32 +68,6 @@ func TestConfigPrepare(t *testing.T) {
 			false,
 		},
 
-		{
-			"client_secrets_file",
-			nil,
-			true,
-		},
-		{
-			"client_secrets_file",
-			testClientSecretsFile(t),
-			false,
-		},
-		{
-			"client_secrets_file",
-			"/tmp/i/should/not/exist",
-			true,
-		},
-
-		{
-			"private_key_file",
-			nil,
-			true,
-		},
-		{
-			"private_key_file",
-			testPrivateKeyFile(t),
-			false,
-		},
 		{
 			"private_key_file",
 			"/tmp/i/should/not/exist",
@@ -174,3 +148,21 @@ func TestConfigPrepare(t *testing.T) {
 		}
 	}
 }
+
+func testAccountFile(t *testing.T) string {
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer tf.Close()
+
+	if _, err := tf.Write([]byte(testAccountContent)); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return tf.Name()
+}
+
+// This is just some dummy data that doesn't actually work (it was revoked
+// a long time ago).
+const testAccountContent = `{}`
diff --git a/builder/googlecompute/driver.go b/builder/googlecompute/driver.go
index 743440e24..da1b52088 100644
--- a/builder/googlecompute/driver.go
+++ b/builder/googlecompute/driver.go
@@ -23,9 +23,15 @@ type Driver interface {
 	WaitForInstance(state, zone, name string) <-chan error
 }
 
+type Image struct {
+	Name      string
+	ProjectId string
+}
+
 type InstanceConfig struct {
 	Description string
-	Image       string
+	DiskSizeGb  int64
+	Image       Image
 	MachineType string
 	Metadata    map[string]string
 	Name        string
diff --git a/builder/googlecompute/driver_gce.go b/builder/googlecompute/driver_gce.go
index 83552aa09..44befad15 100644
--- a/builder/googlecompute/driver_gce.go
+++ b/builder/googlecompute/driver_gce.go
@@ -6,9 +6,9 @@ import (
 	"net/http"
 	"time"
 
-	"code.google.com/p/goauth2/oauth"
-	"code.google.com/p/goauth2/oauth/jwt"
 	"code.google.com/p/google-api-go-client/compute/v1"
+	"github.com/golang/oauth2"
+	"github.com/golang/oauth2/google"
 	"github.com/mitchellh/packer/packer"
 )
 
@@ -20,40 +20,41 @@ type driverGCE struct {
 	ui        packer.Ui
 }
 
-const DriverScopes string = "https://www.googleapis.com/auth/compute " +
-	"https://www.googleapis.com/auth/devstorage.full_control"
+var DriverScopes = []string{"https://www.googleapis.com/auth/compute", "https://www.googleapis.com/auth/devstorage.full_control"}
+
+func NewDriverGCE(ui packer.Ui, p string, a *accountFile) (Driver, error) {
+	var f *oauth2.Flow
+	var err error
+
+	// Auth with AccountFile first if provided
+	if a.PrivateKey != "" {
+		log.Printf("[INFO] Requesting Google token via AccountFile...")
+		log.Printf("[INFO]   -- Email: %s", a.ClientEmail)
+		log.Printf("[INFO]   -- Scopes: %s", DriverScopes)
+		log.Printf("[INFO]   -- Private Key Length: %d", len(a.PrivateKey))
+
+		f, err = oauth2.New(
+			oauth2.JWTClient(a.ClientEmail, []byte(a.PrivateKey)),
+			oauth2.Scope(DriverScopes...),
+			google.JWTEndpoint())
+	} else {
+		log.Printf("[INFO] Requesting Google token via GCE Service Role...")
+
+		f, err = oauth2.New(google.ComputeEngineAccount(""))
+	}
 
-func NewDriverGCE(ui packer.Ui, projectId string, c *clientSecrets, key []byte) (Driver, error) {
-	log.Printf("[INFO] Requesting token...")
-	log.Printf("[INFO]   -- Email: %s", c.Web.ClientEmail)
-	log.Printf("[INFO]   -- Scopes: %s", DriverScopes)
-	log.Printf("[INFO]   -- Private Key Length: %d", len(key))
-	log.Printf("[INFO]   -- Token URL: %s", c.Web.TokenURI)
-	jwtTok := jwt.NewToken(c.Web.ClientEmail, DriverScopes, key)
-	jwtTok.ClaimSet.Aud = c.Web.TokenURI
-	token, err := jwtTok.Assert(new(http.Client))
 	if err != nil {
 		return nil, err
 	}
 
-	transport := &oauth.Transport{
-		Config: &oauth.Config{
-			ClientId: c.Web.ClientId,
-			Scope:    DriverScopes,
-			TokenURL: c.Web.TokenURI,
-			AuthURL:  c.Web.AuthURI,
-		},
-		Token: token,
-	}
-
-	log.Printf("[INFO] Instantiating client...")
-	service, err := compute.New(transport.Client())
+	log.Printf("[INFO] Instantiating GCE client using...")
+	service, err := compute.New(&http.Client{Transport: f.NewTransport()})
 	if err != nil {
 		return nil, err
 	}
 
 	return &driverGCE{
-		projectId: projectId,
+		projectId: p,
 		service:   service,
 		ui:        ui,
 	}, nil
@@ -134,7 +135,7 @@ func (d *driverGCE) RunInstance(c *InstanceConfig) (<-chan error, error) {
 	}
 
 	// Get the image
-	d.ui.Message(fmt.Sprintf("Loading image: %s", c.Image))
+	d.ui.Message(fmt.Sprintf("Loading image: %s in project %s", c.Image.Name, c.Image.ProjectId))
 	image, err := d.getImage(c.Image)
 	if err != nil {
 		return nil, err
@@ -177,6 +178,7 @@ func (d *driverGCE) RunInstance(c *InstanceConfig) (<-chan error, error) {
 				AutoDelete: true,
 				InitializeParams: &compute.AttachedDiskInitializeParams{
 					SourceImage: image.SelfLink,
+					DiskSizeGb:  c.DiskSizeGb,
 				},
 			},
 		},
@@ -228,20 +230,17 @@ func (d *driverGCE) WaitForInstance(state, zone, name string) <-chan error {
 	return errCh
 }
 
-func (d *driverGCE) getImage(name string) (image *compute.Image, err error) {
-	projects := []string{d.projectId, "debian-cloud", "centos-cloud"}
+func (d *driverGCE) getImage(img Image) (image *compute.Image, err error) {
+	projects := []string{img.ProjectId, "centos-cloud", "coreos-cloud", "debian-cloud", "google-containers", "opensuse-cloud", "rhel-cloud", "suse-cloud", "ubuntu-os-cloud", "windows-cloud"}
 	for _, project := range projects {
-		image, err = d.service.Images.Get(project, name).Do()
+		image, err = d.service.Images.Get(project, img.Name).Do()
 		if err == nil && image != nil && image.SelfLink != "" {
 			return
 		}
 		image = nil
 	}
 
-	if err == nil {
-		err = fmt.Errorf("Image could not be found: %s", name)
-	}
-
+	err = fmt.Errorf("Image %s could not be found in any of these projects: %s", img.Name, projects)
 	return
 }
 
diff --git a/builder/googlecompute/step_create_image.go b/builder/googlecompute/step_create_image.go
index 249b59186..ef8026a99 100644
--- a/builder/googlecompute/step_create_image.go
+++ b/builder/googlecompute/step_create_image.go
@@ -31,8 +31,8 @@ func (s *StepCreateImage) Run(state multistep.StateBag) multistep.StepAction {
 
 	ui.Say("Creating image...")
 	cmd := new(packer.RemoteCmd)
-	cmd.Command = fmt.Sprintf("%s%s --output_file_name %s",
-		sudoPrefix, imageBundleCmd, imageFilename)
+	cmd.Command = fmt.Sprintf("%s%s --output_file_name %s --fssize %d",
+		sudoPrefix, imageBundleCmd, imageFilename, config.DiskSizeGb*1024*1024*1024)
 	err := cmd.StartWithUi(comm, ui)
 	if err == nil && cmd.ExitStatus != 0 {
 		err = fmt.Errorf(
diff --git a/builder/googlecompute/step_create_instance.go b/builder/googlecompute/step_create_instance.go
index ff94d5d38..11ca84edc 100644
--- a/builder/googlecompute/step_create_instance.go
+++ b/builder/googlecompute/step_create_instance.go
@@ -16,6 +16,33 @@ type StepCreateInstance struct {
 	instanceName string
 }
 
+func (config *Config) getImage() Image {
+	project := config.ProjectId
+	if config.SourceImageProjectId != "" {
+		project = config.SourceImageProjectId
+	}
+	return Image{Name: config.SourceImage, ProjectId: project}
+}
+
+func (config *Config) getInstanceMetadata(sshPublicKey string) map[string]string {
+	instanceMetadata := make(map[string]string)
+
+	// Copy metadata from config
+	for k, v := range config.Metadata {
+		instanceMetadata[k] = v
+	}
+
+	// Merge any existing ssh keys with our public key
+	sshMetaKey := "sshKeys"
+	sshKeys := fmt.Sprintf("%s:%s", config.SSHUsername, sshPublicKey)
+	if confSshKeys, exists := instanceMetadata[sshMetaKey]; exists {
+		sshKeys = fmt.Sprintf("%s\n%s", sshKeys, confSshKeys)
+	}
+	instanceMetadata[sshMetaKey] = sshKeys
+
+	return instanceMetadata
+}
+
 // Run executes the Packer build step that creates a GCE instance.
 func (s *StepCreateInstance) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*Config)
@@ -28,15 +55,14 @@ func (s *StepCreateInstance) Run(state multistep.StateBag) multistep.StepAction
 
 	errCh, err := driver.RunInstance(&InstanceConfig{
 		Description: "New instance created by Packer",
-		Image:       config.SourceImage,
+		DiskSizeGb:  config.DiskSizeGb,
+		Image:       config.getImage(),
 		MachineType: config.MachineType,
-		Metadata: map[string]string{
-			"sshKeys": fmt.Sprintf("%s:%s", config.SSHUsername, sshPublicKey),
-		},
-		Name:    name,
-		Network: config.Network,
-		Tags:    config.Tags,
-		Zone:    config.Zone,
+		Metadata:    config.getInstanceMetadata(sshPublicKey),
+		Name:        name,
+		Network:     config.Network,
+		Tags:        config.Tags,
+		Zone:        config.Zone,
 	})
 
 	if err == nil {
diff --git a/builder/googlecompute/step_update_gsutil.go b/builder/googlecompute/step_update_gcloud.go
similarity index 69%
rename from builder/googlecompute/step_update_gsutil.go
rename to builder/googlecompute/step_update_gcloud.go
index 9062c500f..3bfc6f2a7 100644
--- a/builder/googlecompute/step_update_gsutil.go
+++ b/builder/googlecompute/step_update_gcloud.go
@@ -7,9 +7,9 @@ import (
 	"github.com/mitchellh/packer/packer"
 )
 
-// StepUpdateGsutil represents a Packer build step that updates the gsutil
+// StepUpdateGcloud represents a Packer build step that updates the gsutil
 // utility to the latest version available.
-type StepUpdateGsutil int
+type StepUpdateGcloud int
 
 // Run executes the Packer build step that updates the gsutil utility to the
 // latest version available.
@@ -17,7 +17,7 @@ type StepUpdateGsutil int
 // This step is required to prevent the image creation process from hanging;
 // the image creation process utilizes the gcimagebundle cli tool which will
 // prompt to update gsutil if a newer version is available.
-func (s *StepUpdateGsutil) Run(state multistep.StateBag) multistep.StepAction {
+func (s *StepUpdateGcloud) Run(state multistep.StateBag) multistep.StepAction {
 	comm := state.Get("communicator").(packer.Communicator)
 	config := state.Get("config").(*Config)
 	ui := state.Get("ui").(packer.Ui)
@@ -28,18 +28,18 @@ func (s *StepUpdateGsutil) Run(state multistep.StateBag) multistep.StepAction {
 		sudoPrefix = "sudo "
 	}
 
-	gsutilUpdateCmd := "/usr/local/bin/gsutil update -n -f"
+	gsutilUpdateCmd := "/usr/local/bin/gcloud -q components update"
 	cmd := new(packer.RemoteCmd)
 	cmd.Command = fmt.Sprintf("%s%s", sudoPrefix, gsutilUpdateCmd)
 
-	ui.Say("Updating gsutil...")
+	ui.Say("Updating gcloud components...")
 	err := cmd.StartWithUi(comm, ui)
 	if err == nil && cmd.ExitStatus != 0 {
 		err = fmt.Errorf(
-			"gsutil update exited with non-zero exit status: %d", cmd.ExitStatus)
+			"gcloud components update exited with non-zero exit status: %d", cmd.ExitStatus)
 	}
 	if err != nil {
-		err := fmt.Errorf("Error updating gsutil: %s", err)
+		err := fmt.Errorf("Error updating gcloud components: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
@@ -49,4 +49,4 @@ func (s *StepUpdateGsutil) Run(state multistep.StateBag) multistep.StepAction {
 }
 
 // Cleanup.
-func (s *StepUpdateGsutil) Cleanup(state multistep.StateBag) {}
+func (s *StepUpdateGcloud) Cleanup(state multistep.StateBag) {}
diff --git a/builder/googlecompute/step_update_gsutil_test.go b/builder/googlecompute/step_update_gcloud_test.go
similarity index 75%
rename from builder/googlecompute/step_update_gsutil_test.go
rename to builder/googlecompute/step_update_gcloud_test.go
index 966857f93..b01406f10 100644
--- a/builder/googlecompute/step_update_gsutil_test.go
+++ b/builder/googlecompute/step_update_gcloud_test.go
@@ -8,13 +8,13 @@ import (
 	"github.com/mitchellh/packer/packer"
 )
 
-func TestStepUpdateGsutil_impl(t *testing.T) {
-	var _ multistep.Step = new(StepUpdateGsutil)
+func TestStepUpdateGcloud_impl(t *testing.T) {
+	var _ multistep.Step = new(StepUpdateGcloud)
 }
 
-func TestStepUpdateGsutil(t *testing.T) {
+func TestStepUpdateGcloud(t *testing.T) {
 	state := testState(t)
-	step := new(StepUpdateGsutil)
+	step := new(StepUpdateGcloud)
 	defer step.Cleanup(state)
 
 	comm := new(packer.MockCommunicator)
@@ -32,14 +32,14 @@ func TestStepUpdateGsutil(t *testing.T) {
 	if strings.HasPrefix(comm.StartCmd.Command, "sudo") {
 		t.Fatal("should not sudo")
 	}
-	if !strings.Contains(comm.StartCmd.Command, "gsutil update") {
+	if !strings.Contains(comm.StartCmd.Command, "gcloud -q components update") {
 		t.Fatalf("bad command: %#v", comm.StartCmd.Command)
 	}
 }
 
-func TestStepUpdateGsutil_badExitStatus(t *testing.T) {
+func TestStepUpdateGcloud_badExitStatus(t *testing.T) {
 	state := testState(t)
-	step := new(StepUpdateGsutil)
+	step := new(StepUpdateGcloud)
 	defer step.Cleanup(state)
 
 	comm := new(packer.MockCommunicator)
@@ -56,9 +56,9 @@ func TestStepUpdateGsutil_badExitStatus(t *testing.T) {
 	}
 }
 
-func TestStepUpdateGsutil_nonRoot(t *testing.T) {
+func TestStepUpdateGcloud_nonRoot(t *testing.T) {
 	state := testState(t)
-	step := new(StepUpdateGsutil)
+	step := new(StepUpdateGcloud)
 	defer step.Cleanup(state)
 
 	comm := new(packer.MockCommunicator)
@@ -79,7 +79,7 @@ func TestStepUpdateGsutil_nonRoot(t *testing.T) {
 	if !strings.HasPrefix(comm.StartCmd.Command, "sudo") {
 		t.Fatal("should sudo")
 	}
-	if !strings.Contains(comm.StartCmd.Command, "gsutil update") {
+	if !strings.Contains(comm.StartCmd.Command, "gcloud -q components update") {
 		t.Fatalf("bad command: %#v", comm.StartCmd.Command)
 	}
 }
diff --git a/builder/null/artifact_export.go b/builder/null/artifact_export.go
index ad7bebc15..3962358e0 100644
--- a/builder/null/artifact_export.go
+++ b/builder/null/artifact_export.go
@@ -24,6 +24,10 @@ func (a *NullArtifact) String() string {
 	return fmt.Sprintf("Did not export anything. This is the null builder")
 }
 
+func (a *NullArtifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *NullArtifact) Destroy() error {
 	return nil
 }
diff --git a/builder/null/config.go b/builder/null/config.go
index 94f3b21e7..4823df8ae 100644
--- a/builder/null/config.go
+++ b/builder/null/config.go
@@ -32,14 +32,28 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 
 	c.tpl.UserVars = c.PackerUserVars
 
-	// Defaults
 	if c.Port == 0 {
 		c.Port = 22
 	}
-	// (none so far)
 
 	errs := common.CheckUnusedConfig(md)
 
+	templates := map[string]*string{
+		"host":                 &c.Host,
+		"ssh_username":         &c.SSHUsername,
+		"ssh_password":         &c.SSHPassword,
+		"ssh_private_key_file": &c.SSHPrivateKeyFile,
+	}
+
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = c.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
 	if c.Host == "" {
 		errs = packer.MultiErrorAppend(errs,
 			fmt.Errorf("host must be specified"))
diff --git a/builder/openstack/access_config.go b/builder/openstack/access_config.go
index 98bc05779..502df161f 100644
--- a/builder/openstack/access_config.go
+++ b/builder/openstack/access_config.go
@@ -1,14 +1,16 @@
 package openstack
 
 import (
+	"crypto/tls"
 	"fmt"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"github.com/rackspace/gophercloud"
 	"net/http"
 	"net/url"
 	"os"
 	"strings"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 // AccessConfig is for common configuration related to openstack access
@@ -20,6 +22,8 @@ type AccessConfig struct {
 	Provider  string `mapstructure:"provider"`
 	RawRegion string `mapstructure:"region"`
 	ProxyUrl  string `mapstructure:"proxy_url"`
+	TenantId  string `mapstructure:"tenant_id"`
+	Insecure  bool   `mapstructure:"insecure"`
 }
 
 // Auth returns a valid Auth object for access to openstack services, or
@@ -31,6 +35,7 @@ func (c *AccessConfig) Auth() (gophercloud.AccessProvider, error) {
 	c.Project = common.ChooseString(c.Project, os.Getenv("SDK_PROJECT"), os.Getenv("OS_TENANT_NAME"))
 	c.Provider = common.ChooseString(c.Provider, os.Getenv("SDK_PROVIDER"), os.Getenv("OS_AUTH_URL"))
 	c.RawRegion = common.ChooseString(c.RawRegion, os.Getenv("SDK_REGION"), os.Getenv("OS_REGION_NAME"))
+	c.TenantId = common.ChooseString(c.TenantId, os.Getenv("OS_TENANT_ID"))
 
 	// OpenStack's auto-generated openrc.sh files do not append the suffix
 	// /tokens to the authentication URL. This ensures it is present when
@@ -40,14 +45,21 @@ func (c *AccessConfig) Auth() (gophercloud.AccessProvider, error) {
 	}
 
 	authoptions := gophercloud.AuthOptions{
-		Username:    c.Username,
-		Password:    c.Password,
-		ApiKey:      c.ApiKey,
 		AllowReauth: true,
+
+		ApiKey:     c.ApiKey,
+		TenantId:   c.TenantId,
+		TenantName: c.Project,
+		Username:   c.Username,
+		Password:   c.Password,
 	}
 
-	if c.Project != "" {
-		authoptions.TenantName = c.Project
+	default_transport := &http.Transport{}
+
+	if c.Insecure {
+		cfg := new(tls.Config)
+		cfg.InsecureSkipVerify = true
+		default_transport.TLSClientConfig = cfg
 	}
 
 	// For corporate networks it may be the case where we want our API calls
@@ -60,7 +72,11 @@ func (c *AccessConfig) Auth() (gophercloud.AccessProvider, error) {
 
 		// The gophercloud.Context has a UseCustomClient method which
 		// would allow us to override with a new instance of http.Client.
-		http.DefaultTransport = &http.Transport{Proxy: http.ProxyURL(url)}
+		default_transport.Proxy = http.ProxyURL(url)
+	}
+
+	if c.Insecure || c.ProxyUrl != "" {
+		http.DefaultTransport = default_transport
 	}
 
 	return gophercloud.Authenticate(c.Provider, authoptions)
@@ -80,10 +96,14 @@ func (c *AccessConfig) Prepare(t *packer.ConfigTemplate) []error {
 	}
 
 	templates := map[string]*string{
-		"username": &c.Username,
-		"password": &c.Password,
-		"apiKey":   &c.ApiKey,
-		"provider": &c.Provider,
+		"username":  &c.Username,
+		"password":  &c.Password,
+		"api_key":   &c.ApiKey,
+		"provider":  &c.Provider,
+		"project":   &c.Project,
+		"tenant_id": &c.TenantId,
+		"region":    &c.RawRegion,
+		"proxy_url": &c.ProxyUrl,
 	}
 
 	errs := make([]error, 0)
@@ -96,8 +116,10 @@ func (c *AccessConfig) Prepare(t *packer.ConfigTemplate) []error {
 		}
 	}
 
-	if c.Region() == "" {
-		errs = append(errs, fmt.Errorf("region must be specified"))
+	if strings.HasPrefix(c.Provider, "rackspace") {
+		if c.Region() == "" {
+			errs = append(errs, fmt.Errorf("region must be specified when using rackspace"))
+		}
 	}
 
 	if len(errs) > 0 {
diff --git a/builder/openstack/access_config_test.go b/builder/openstack/access_config_test.go
index 7a9e5201e..5c92216e3 100644
--- a/builder/openstack/access_config_test.go
+++ b/builder/openstack/access_config_test.go
@@ -8,13 +8,22 @@ func testAccessConfig() *AccessConfig {
 	return &AccessConfig{}
 }
 
-func TestAccessConfigPrepare_NoRegion(t *testing.T) {
+func TestAccessConfigPrepare_NoRegion_Rackspace(t *testing.T) {
 	c := testAccessConfig()
+	c.Provider = "rackspace-us"
 	if err := c.Prepare(nil); err == nil {
 		t.Fatalf("shouldn't have err: %s", err)
 	}
 }
 
+func TestAccessConfigPrepare_NoRegion_PrivateCloud(t *testing.T) {
+	c := testAccessConfig()
+	c.Provider = "http://some-keystone-server:5000/v2.0"
+	if err := c.Prepare(nil); err != nil {
+		t.Fatalf("shouldn't have err: %s", err)
+	}
+}
+
 func TestAccessConfigPrepare_Region(t *testing.T) {
 	dfw := "DFW"
 	c := testAccessConfig()
diff --git a/builder/openstack/artifact.go b/builder/openstack/artifact.go
index a2ba552c5..f55ff8727 100644
--- a/builder/openstack/artifact.go
+++ b/builder/openstack/artifact.go
@@ -2,8 +2,9 @@ package openstack
 
 import (
 	"fmt"
-	"github.com/rackspace/gophercloud"
 	"log"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 // Artifact is an artifact implementation that contains built images.
@@ -35,6 +36,10 @@ func (a *Artifact) String() string {
 	return fmt.Sprintf("An image was created: %v", a.ImageId)
 }
 
+func (a *Artifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *Artifact) Destroy() error {
 	log.Printf("Destroying image: %d", a.ImageId)
 	return a.Conn.DeleteImageById(a.ImageId)
diff --git a/builder/openstack/builder.go b/builder/openstack/builder.go
index d63e847f2..0038ea9a0 100644
--- a/builder/openstack/builder.go
+++ b/builder/openstack/builder.go
@@ -8,8 +8,9 @@ import (
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"github.com/rackspace/gophercloud"
 	"log"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 // The unique ID for this builder
@@ -88,9 +89,15 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			DebugKeyPath: fmt.Sprintf("os_%s.pem", b.config.PackerBuildName),
 		},
 		&StepRunSourceServer{
-			Name:        b.config.ImageName,
-			Flavor:      b.config.Flavor,
-			SourceImage: b.config.SourceImage,
+			Name:           b.config.ImageName,
+			Flavor:         b.config.Flavor,
+			SourceImage:    b.config.SourceImage,
+			SecurityGroups: b.config.SecurityGroups,
+			Networks:       b.config.Networks,
+		},
+		&StepAllocateIp{
+			FloatingIpPool: b.config.FloatingIpPool,
+			FloatingIp:     b.config.FloatingIp,
 		},
 		&common.StepConnectSSH{
 			SSHAddress:     SSHAddress(csp, b.config.SSHPort),
diff --git a/builder/openstack/run_config.go b/builder/openstack/run_config.go
index 688d681a5..a1ca0f0ae 100644
--- a/builder/openstack/run_config.go
+++ b/builder/openstack/run_config.go
@@ -10,12 +10,17 @@ import (
 // RunConfig contains configuration for running an instance from a source
 // image and details on how to access that launched image.
 type RunConfig struct {
-	SourceImage       string `mapstructure:"source_image"`
-	Flavor            string `mapstructure:"flavor"`
-	RawSSHTimeout     string `mapstructure:"ssh_timeout"`
-	SSHUsername       string `mapstructure:"ssh_username"`
-	SSHPort           int    `mapstructure:"ssh_port"`
-	OpenstackProvider string `mapstructure:"openstack_provider"`
+	SourceImage       string   `mapstructure:"source_image"`
+	Flavor            string   `mapstructure:"flavor"`
+	RawSSHTimeout     string   `mapstructure:"ssh_timeout"`
+	SSHUsername       string   `mapstructure:"ssh_username"`
+	SSHPort           int      `mapstructure:"ssh_port"`
+	OpenstackProvider string   `mapstructure:"openstack_provider"`
+	UseFloatingIp     bool     `mapstructure:"use_floating_ip"`
+	FloatingIpPool    string   `mapstructure:"floating_ip_pool"`
+	FloatingIp        string   `mapstructure:"floating_ip"`
+	SecurityGroups    []string `mapstructure:"security_groups"`
+	Networks          []string `mapstructure:"networks"`
 
 	// Unexported fields that are calculated from others
 	sshTimeout time.Duration
@@ -43,6 +48,10 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		c.RawSSHTimeout = "5m"
 	}
 
+	if c.UseFloatingIp && c.FloatingIpPool == "" {
+		c.FloatingIpPool = "public"
+	}
+
 	// Validation
 	var err error
 	errs := make([]error, 0)
@@ -59,7 +68,7 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 	}
 
 	templates := map[string]*string{
-		"flavlor":      &c.Flavor,
+		"flavor":       &c.Flavor,
 		"ssh_timeout":  &c.RawSSHTimeout,
 		"ssh_username": &c.SSHUsername,
 		"source_image": &c.SourceImage,
@@ -69,8 +78,7 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		var err error
 		*ptr, err = t.Process(*ptr, nil)
 		if err != nil {
-			errs = append(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
 		}
 	}
 
diff --git a/builder/openstack/server.go b/builder/openstack/server.go
index fb48659b1..ba22dd3e2 100644
--- a/builder/openstack/server.go
+++ b/builder/openstack/server.go
@@ -4,9 +4,11 @@ import (
 	"errors"
 	"fmt"
 	"github.com/mitchellh/multistep"
-	"github.com/rackspace/gophercloud"
+	"github.com/racker/perigee"
 	"log"
 	"time"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 // StateRefreshFunc is a function type used for StateChangeConf that is
@@ -30,15 +32,21 @@ type StateChangeConf struct {
 }
 
 // ServerStateRefreshFunc returns a StateRefreshFunc that is used to watch
-// an openstacn server.
+// an openstack server.
 func ServerStateRefreshFunc(csp gophercloud.CloudServersProvider, s *gophercloud.Server) StateRefreshFunc {
 	return func() (interface{}, string, int, error) {
 		resp, err := csp.ServerById(s.Id)
 		if err != nil {
-			log.Printf("Error on ServerStateRefresh: %s", err)
-			return nil, "", 0, err
-		}
+			urce, ok := err.(*perigee.UnexpectedResponseCodeError)
+			if ok && (urce.Actual == 404) {
+				log.Printf("404 on ServerStateRefresh, returning DELETED")
 
+				return nil, "DELETED", 0, nil
+			} else {
+				log.Printf("Error on ServerStateRefresh: %s", err)
+				return nil, "", 0, err
+			}
+		}
 		return resp, resp.Status, resp.Progress, nil
 	}
 }
diff --git a/builder/openstack/ssh.go b/builder/openstack/ssh.go
index a27a7f3c4..055850663 100644
--- a/builder/openstack/ssh.go
+++ b/builder/openstack/ssh.go
@@ -5,32 +5,44 @@ import (
 	"errors"
 	"fmt"
 	"github.com/mitchellh/multistep"
-	"github.com/rackspace/gophercloud"
 	"time"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 // SSHAddress returns a function that can be given to the SSH communicator
 // for determining the SSH address based on the server AccessIPv4 setting..
 func SSHAddress(csp gophercloud.CloudServersProvider, port int) func(multistep.StateBag) (string, error) {
 	return func(state multistep.StateBag) (string, error) {
-		for j := 0; j < 2; j++ {
-			s := state.Get("server").(*gophercloud.Server)
-			if s.AccessIPv4 != "" {
-				return fmt.Sprintf("%s:%d", s.AccessIPv4, port), nil
-			}
-			if s.AccessIPv6 != "" {
-				return fmt.Sprintf("[%s]:%d", s.AccessIPv6, port), nil
-			}
-			serverState, err := csp.ServerById(s.Id)
+		s := state.Get("server").(*gophercloud.Server)
 
-			if err != nil {
-				return "", err
-			}
-
-			state.Put("server", serverState)
-			time.Sleep(1 * time.Second)
+		if ip := state.Get("access_ip").(gophercloud.FloatingIp); ip.Ip != "" {
+			return fmt.Sprintf("%s:%d", ip.Ip, port), nil
 		}
 
+		ip_pools, err := s.AllAddressPools()
+		if err != nil {
+			return "", errors.New("Error parsing SSH addresses")
+		}
+		for pool, addresses := range ip_pools {
+			if pool != "" {
+				for _, address := range addresses {
+					if address.Addr != "" && address.Version == 4 {
+						return fmt.Sprintf("%s:%d", address.Addr, port), nil
+					}
+				}
+			}
+		}
+
+		serverState, err := csp.ServerById(s.Id)
+
+		if err != nil {
+			return "", err
+		}
+
+		state.Put("server", serverState)
+		time.Sleep(1 * time.Second)
+
 		return "", errors.New("couldn't determine IP address for server")
 	}
 }
diff --git a/builder/openstack/step_allocate_ip.go b/builder/openstack/step_allocate_ip.go
new file mode 100644
index 000000000..b64f8b617
--- /dev/null
+++ b/builder/openstack/step_allocate_ip.go
@@ -0,0 +1,67 @@
+package openstack
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
+)
+
+type StepAllocateIp struct {
+	FloatingIpPool string
+	FloatingIp     string
+}
+
+func (s *StepAllocateIp) Run(state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
+	csp := state.Get("csp").(gophercloud.CloudServersProvider)
+	server := state.Get("server").(*gophercloud.Server)
+
+	var instanceIp gophercloud.FloatingIp
+	// This is here in case we error out before putting instanceIp into the
+	// statebag below, because it is requested by Cleanup()
+	state.Put("access_ip", instanceIp)
+
+	if s.FloatingIp != "" {
+		instanceIp.Ip = s.FloatingIp
+	} else if s.FloatingIpPool != "" {
+		newIp, err := csp.CreateFloatingIp(s.FloatingIpPool)
+		if err != nil {
+			err := fmt.Errorf("Error creating floating ip from pool '%s'", s.FloatingIpPool)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		instanceIp = newIp
+		ui.Say(fmt.Sprintf("Created temporary floating IP %s...", instanceIp.Ip))
+	}
+
+	if instanceIp.Ip != "" {
+		if err := csp.AssociateFloatingIp(server.Id, instanceIp); err != nil {
+			err := fmt.Errorf("Error associating floating IP %s with instance.", instanceIp.Ip)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		} else {
+			ui.Say(fmt.Sprintf("Added floating IP %s to instance...", instanceIp.Ip))
+		}
+	}
+
+	state.Put("access_ip", instanceIp)
+
+	return multistep.ActionContinue
+}
+
+func (s *StepAllocateIp) Cleanup(state multistep.StateBag) {
+	ui := state.Get("ui").(packer.Ui)
+	csp := state.Get("csp").(gophercloud.CloudServersProvider)
+	instanceIp := state.Get("access_ip").(gophercloud.FloatingIp)
+	if s.FloatingIpPool != "" && instanceIp.Id != 0 {
+		if err := csp.DeleteFloatingIp(instanceIp); err != nil {
+			ui.Error(fmt.Sprintf("Error deleting temporary floating IP %s", instanceIp.Ip))
+			return
+		}
+		ui.Say(fmt.Sprintf("Deleted temporary floating IP %s", instanceIp.Ip))
+	}
+}
diff --git a/builder/openstack/step_create_image.go b/builder/openstack/step_create_image.go
index bed26aea8..a95eaff34 100644
--- a/builder/openstack/step_create_image.go
+++ b/builder/openstack/step_create_image.go
@@ -4,9 +4,10 @@ import (
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"github.com/rackspace/gophercloud"
 	"log"
 	"time"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 type stepCreateImage struct{}
diff --git a/builder/openstack/step_key_pair.go b/builder/openstack/step_key_pair.go
index 8f729b40f..9c46b4377 100644
--- a/builder/openstack/step_key_pair.go
+++ b/builder/openstack/step_key_pair.go
@@ -5,10 +5,11 @@ import (
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/common/uuid"
 	"github.com/mitchellh/packer/packer"
-	"github.com/rackspace/gophercloud"
 	"log"
 	"os"
 	"runtime"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 type StepKeyPair struct {
@@ -29,6 +30,10 @@ func (s *StepKeyPair) Run(state multistep.StateBag) multistep.StepAction {
 		state.Put("error", fmt.Errorf("Error creating temporary keypair: %s", err))
 		return multistep.ActionHalt
 	}
+	if keyResp.PrivateKey == "" {
+		state.Put("error", fmt.Errorf("The temporary keypair returned was blank"))
+		return multistep.ActionHalt
+	}
 
 	// If we're in debug mode, output the private key to the working
 	// directory.
diff --git a/builder/openstack/step_run_source_server.go b/builder/openstack/step_run_source_server.go
index c8e121e09..19e7f024d 100644
--- a/builder/openstack/step_run_source_server.go
+++ b/builder/openstack/step_run_source_server.go
@@ -4,14 +4,17 @@ import (
 	"fmt"
 	"github.com/mitchellh/multistep"
 	"github.com/mitchellh/packer/packer"
-	"github.com/rackspace/gophercloud"
 	"log"
+
+	"github.com/mitchellh/gophercloud-fork-40444fb"
 )
 
 type StepRunSourceServer struct {
-	Flavor      string
-	Name        string
-	SourceImage string
+	Flavor         string
+	Name           string
+	SourceImage    string
+	SecurityGroups []string
+	Networks       []string
 
 	server *gophercloud.Server
 }
@@ -23,11 +26,24 @@ func (s *StepRunSourceServer) Run(state multistep.StateBag) multistep.StepAction
 
 	// XXX - validate image and flavor is available
 
+	securityGroups := make([]map[string]interface{}, len(s.SecurityGroups))
+	for i, groupName := range s.SecurityGroups {
+		securityGroups[i] = make(map[string]interface{})
+		securityGroups[i]["name"] = groupName
+	}
+
+	networks := make([]gophercloud.NetworkConfig, len(s.Networks))
+	for i, networkUuid := range s.Networks {
+		networks[i].Uuid = networkUuid
+	}
+
 	server := gophercloud.NewServer{
-		Name:        s.Name,
-		ImageRef:    s.SourceImage,
-		FlavorRef:   s.Flavor,
-		KeyPairName: keyName,
+		Name:          s.Name,
+		ImageRef:      s.SourceImage,
+		FlavorRef:     s.Flavor,
+		KeyPairName:   keyName,
+		SecurityGroup: securityGroups,
+		Networks:      networks,
 	}
 
 	serverResp, err := csp.CreateServer(server)
diff --git a/builder/parallels/common/artifact.go b/builder/parallels/common/artifact.go
new file mode 100644
index 000000000..8ce7755fa
--- /dev/null
+++ b/builder/parallels/common/artifact.go
@@ -0,0 +1,75 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+	"os"
+	"path/filepath"
+	"regexp"
+)
+
+// This is the common builder ID to all of these artifacts.
+const BuilderId = "packer.parallels"
+
+// These are the extensions of files and directories that are unnecessary for the function
+// of a Parallels virtual machine.
+var unnecessaryFiles = []string{"\\.log$", "\\.backup$", "\\.Backup$", "\\.app"}
+
+// Artifact is the result of running the parallels builder, namely a set
+// of files associated with the resulting machine.
+type artifact struct {
+	dir string
+	f   []string
+}
+
+// NewArtifact returns a Parallels artifact containing the files
+// in the given directory.
+func NewArtifact(dir string) (packer.Artifact, error) {
+	files := make([]string, 0, 5)
+	visit := func(path string, info os.FileInfo, err error) error {
+		for _, unnecessaryFile := range unnecessaryFiles {
+			if unnecessary, _ := regexp.MatchString(unnecessaryFile, path); unnecessary {
+				return os.RemoveAll(path)
+			}
+		}
+
+		if !info.IsDir() {
+			files = append(files, path)
+		}
+
+		return err
+	}
+
+	if err := filepath.Walk(dir, visit); err != nil {
+		return nil, err
+	}
+
+	return &artifact{
+		dir: dir,
+		f:   files,
+	}, nil
+}
+
+func (*artifact) BuilderId() string {
+	return BuilderId
+}
+
+func (a *artifact) Files() []string {
+	return a.f
+}
+
+func (*artifact) Id() string {
+	return "VM"
+}
+
+func (a *artifact) String() string {
+	return fmt.Sprintf("VM files in directory: %s", a.dir)
+}
+
+func (a *artifact) State(name string) interface{} {
+	return nil
+}
+
+func (a *artifact) Destroy() error {
+	return os.RemoveAll(a.dir)
+}
diff --git a/builder/parallels/common/artifact_test.go b/builder/parallels/common/artifact_test.go
new file mode 100644
index 000000000..f9ddc5dbf
--- /dev/null
+++ b/builder/parallels/common/artifact_test.go
@@ -0,0 +1,43 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/mitchellh/packer/packer"
+)
+
+func TestArtifact_impl(t *testing.T) {
+	var _ packer.Artifact = new(artifact)
+}
+
+func TestNewArtifact(t *testing.T) {
+	td, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.RemoveAll(td)
+
+	err = ioutil.WriteFile(filepath.Join(td, "a"), []byte("foo"), 0644)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if err := os.Mkdir(filepath.Join(td, "b"), 0755); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	a, err := NewArtifact(td)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if a.BuilderId() != BuilderId {
+		t.Fatalf("bad: %#v", a.BuilderId())
+	}
+	if len(a.Files()) != 1 {
+		t.Fatalf("should length 1: %d", len(a.Files()))
+	}
+}
diff --git a/builder/parallels/common/config_test.go b/builder/parallels/common/config_test.go
new file mode 100644
index 000000000..a84c51bc1
--- /dev/null
+++ b/builder/parallels/common/config_test.go
@@ -0,0 +1,15 @@
+package common
+
+import (
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func testConfigTemplate(t *testing.T) *packer.ConfigTemplate {
+	result, err := packer.NewConfigTemplate()
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return result
+}
diff --git a/builder/parallels/common/driver.go b/builder/parallels/common/driver.go
new file mode 100644
index 000000000..771395d8c
--- /dev/null
+++ b/builder/parallels/common/driver.go
@@ -0,0 +1,96 @@
+package common
+
+import (
+	"fmt"
+	"log"
+	"os/exec"
+	"runtime"
+	"strings"
+)
+
+// A driver is able to talk to Parallels and perform certain
+// operations with it. Some of the operations on here may seem overly
+// specific, but they were built specifically in mind to handle features
+// of the Parallels builder for Packer, and to abstract differences in
+// versions out of the builder steps, so sometimes the methods are
+// extremely specific.
+type Driver interface {
+	// Adds new CD/DVD drive to the VM and returns name of this device
+	DeviceAddCdRom(string, string) (string, error)
+
+	// Import a VM
+	Import(string, string, string, bool) error
+
+	// Checks if the VM with the given name is running.
+	IsRunning(string) (bool, error)
+
+	// Stop stops a running machine, forcefully.
+	Stop(string) error
+
+	// Prlctl executes the given Prlctl command
+	Prlctl(...string) error
+
+	// Get the path to the Parallels Tools ISO for the given flavor.
+	ToolsIsoPath(string) (string, error)
+
+	// Verify checks to make sure that this driver should function
+	// properly. If there is any indication the driver can't function,
+	// this will return an error.
+	Verify() error
+
+	// Version reads the version of Parallels that is installed.
+	Version() (string, error)
+
+	// Send scancodes to the vm using the prltype python script.
+	SendKeyScanCodes(string, ...string) error
+
+	// Finds the MAC address of the NIC nic0
+	Mac(string) (string, error)
+
+	// Finds the IP address of a VM connected that uses DHCP by its MAC address
+	IpAddress(string) (string, error)
+}
+
+func NewDriver() (Driver, error) {
+	var drivers map[string]Driver
+	var prlctlPath string
+	var supportedVersions []string
+
+	if runtime.GOOS != "darwin" {
+		return nil, fmt.Errorf(
+			"Parallels builder works only on \"darwin\" platform!")
+	}
+
+	if prlctlPath == "" {
+		var err error
+		prlctlPath, err = exec.LookPath("prlctl")
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	log.Printf("prlctl path: %s", prlctlPath)
+
+	drivers = map[string]Driver{
+		"10": &Parallels10Driver{
+			Parallels9Driver: Parallels9Driver{
+				PrlctlPath: prlctlPath,
+			},
+		},
+		"9": &Parallels9Driver{
+			PrlctlPath: prlctlPath,
+		},
+	}
+
+	for v, d := range drivers {
+		version, _ := d.Version()
+		if strings.HasPrefix(version, v) {
+			return d, nil
+		}
+		supportedVersions = append(supportedVersions, v)
+	}
+
+	return nil, fmt.Errorf(
+		"Unable to initialize any driver. Supported Parallels Desktop versions: "+
+			"%s\n", strings.Join(supportedVersions, ", "))
+}
diff --git a/builder/parallels/common/driver_10.go b/builder/parallels/common/driver_10.go
new file mode 100644
index 000000000..ae39240f4
--- /dev/null
+++ b/builder/parallels/common/driver_10.go
@@ -0,0 +1,6 @@
+package common
+
+// Parallels10Driver are inherited from Parallels9Driver.
+type Parallels10Driver struct {
+	Parallels9Driver
+}
diff --git a/builder/parallels/common/driver_9.go b/builder/parallels/common/driver_9.go
new file mode 100644
index 000000000..7661a30c7
--- /dev/null
+++ b/builder/parallels/common/driver_9.go
@@ -0,0 +1,315 @@
+package common
+
+import (
+	"bytes"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"time"
+
+	"github.com/going/toolkit/xmlpath"
+)
+
+type Parallels9Driver struct {
+	// This is the path to the "prlctl" application.
+	PrlctlPath string
+}
+
+func (d *Parallels9Driver) Import(name, srcPath, dstDir string, reassignMac bool) error {
+
+	err := d.Prlctl("register", srcPath, "--preserve-uuid")
+	if err != nil {
+		return err
+	}
+
+	srcId, err := getVmId(srcPath)
+	if err != nil {
+		return err
+	}
+
+	srcMac := "auto"
+	if !reassignMac {
+		srcMac, err = getFirtsMacAddress(srcPath)
+		if err != nil {
+			return err
+		}
+	}
+
+	err = d.Prlctl("clone", srcId, "--name", name, "--dst", dstDir)
+	if err != nil {
+		return err
+	}
+
+	err = d.Prlctl("unregister", srcId)
+	if err != nil {
+		return err
+	}
+
+	err = d.Prlctl("set", name, "--device-set", "net0", "--mac", srcMac)
+	return nil
+}
+
+func getVmId(path string) (string, error) {
+	return getConfigValueFromXpath(path, "/ParallelsVirtualMachine/Identification/VmUuid")
+}
+
+func getFirtsMacAddress(path string) (string, error) {
+	return getConfigValueFromXpath(path, "/ParallelsVirtualMachine/Hardware/NetworkAdapter[@id='0']/MAC")
+}
+
+func getConfigValueFromXpath(path, xpath string) (string, error) {
+	file, err := os.Open(path + "/config.pvs")
+	if err != nil {
+		return "", err
+	}
+	xpathComp := xmlpath.MustCompile(xpath)
+	root, err := xmlpath.Parse(file)
+	if err != nil {
+		return "", err
+	}
+	value, _ := xpathComp.String(root)
+	return value, nil
+}
+
+// Finds an application bundle by identifier (for "darwin" platform only)
+func getAppPath(bundleId string) (string, error) {
+	var stdout bytes.Buffer
+
+	cmd := exec.Command("mdfind", "kMDItemCFBundleIdentifier ==", bundleId)
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+
+	pathOutput := strings.TrimSpace(stdout.String())
+	if pathOutput == "" {
+		return "", fmt.Errorf(
+			"Could not detect Parallels Desktop! Make sure it is properly installed.")
+	}
+
+	return pathOutput, nil
+}
+
+func (d *Parallels9Driver) DeviceAddCdRom(name string, image string) (string, error) {
+	command := []string{
+		"set", name,
+		"--device-add", "cdrom",
+		"--image", image,
+	}
+
+	out, err := exec.Command(d.PrlctlPath, command...).Output()
+	if err != nil {
+		return "", err
+	}
+
+	deviceRe := regexp.MustCompile(`\s+(cdrom\d+)\s+`)
+	matches := deviceRe.FindStringSubmatch(string(out))
+	if matches == nil {
+		return "", fmt.Errorf(
+			"Could not determine cdrom device name in the output:\n%s", string(out))
+	}
+
+	device_name := matches[1]
+	return device_name, nil
+}
+
+func (d *Parallels9Driver) IsRunning(name string) (bool, error) {
+	var stdout bytes.Buffer
+
+	cmd := exec.Command(d.PrlctlPath, "list", name, "--no-header", "--output", "status")
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		return false, err
+	}
+
+	log.Printf("Checking VM state: %s\n", strings.TrimSpace(stdout.String()))
+
+	for _, line := range strings.Split(stdout.String(), "\n") {
+		if line == "running" {
+			return true, nil
+		}
+
+		if line == "suspended" {
+			return true, nil
+		}
+		if line == "paused" {
+			return true, nil
+		}
+		if line == "stopping" {
+			return true, nil
+		}
+	}
+
+	return false, nil
+}
+
+func (d *Parallels9Driver) Stop(name string) error {
+	if err := d.Prlctl("stop", name); err != nil {
+		return err
+	}
+
+	// We sleep here for a little bit to let the session "unlock"
+	time.Sleep(2 * time.Second)
+
+	return nil
+}
+
+func (d *Parallels9Driver) Prlctl(args ...string) error {
+	var stdout, stderr bytes.Buffer
+
+	log.Printf("Executing prlctl: %#v", args)
+	cmd := exec.Command(d.PrlctlPath, args...)
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err := cmd.Run()
+
+	stdoutString := strings.TrimSpace(stdout.String())
+	stderrString := strings.TrimSpace(stderr.String())
+
+	if _, ok := err.(*exec.ExitError); ok {
+		err = fmt.Errorf("prlctl error: %s", stderrString)
+	}
+
+	log.Printf("stdout: %s", stdoutString)
+	log.Printf("stderr: %s", stderrString)
+
+	return err
+}
+
+func (d *Parallels9Driver) Verify() error {
+	return nil
+}
+
+func (d *Parallels9Driver) Version() (string, error) {
+	out, err := exec.Command(d.PrlctlPath, "--version").Output()
+	if err != nil {
+		return "", err
+	}
+
+	versionRe := regexp.MustCompile(`prlctl version (\d+\.\d+.\d+)`)
+	matches := versionRe.FindStringSubmatch(string(out))
+	if matches == nil {
+		return "", fmt.Errorf(
+			"Could not find Parallels Desktop version in output:\n%s", string(out))
+	}
+
+	version := matches[1]
+	log.Printf("Parallels Desktop version: %s", version)
+	return version, nil
+}
+
+func (d *Parallels9Driver) SendKeyScanCodes(vmName string, codes ...string) error {
+	var stdout, stderr bytes.Buffer
+
+	if codes == nil || len(codes) == 0 {
+		log.Printf("No scan codes to send")
+		return nil
+	}
+
+	f, err := ioutil.TempFile("", "prltype")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(f.Name())
+
+	script := []byte(Prltype)
+	_, err = f.Write(script)
+	if err != nil {
+		return err
+	}
+
+	args := prepend(vmName, codes)
+	args = prepend(f.Name(), args)
+	cmd := exec.Command("/usr/bin/python", args...)
+	cmd.Stdout = &stdout
+	cmd.Stderr = &stderr
+	err = cmd.Run()
+
+	stdoutString := strings.TrimSpace(stdout.String())
+	stderrString := strings.TrimSpace(stderr.String())
+
+	if _, ok := err.(*exec.ExitError); ok {
+		err = fmt.Errorf("prltype error: %s", stderrString)
+	}
+
+	log.Printf("stdout: %s", stdoutString)
+	log.Printf("stderr: %s", stderrString)
+
+	return err
+}
+
+func prepend(head string, tail []string) []string {
+	tmp := make([]string, len(tail)+1)
+	for i := 0; i < len(tail); i++ {
+		tmp[i+1] = tail[i]
+	}
+	tmp[0] = head
+	return tmp
+}
+
+func (d *Parallels9Driver) Mac(vmName string) (string, error) {
+	var stdout bytes.Buffer
+
+	cmd := exec.Command(d.PrlctlPath, "list", "-i", vmName)
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		log.Printf("MAC address for NIC: nic0 on Virtual Machine: %s not found!\n", vmName)
+		return "", err
+	}
+
+	stdoutString := strings.TrimSpace(stdout.String())
+	re := regexp.MustCompile("net0.* mac=([0-9A-F]{12}) card=.*")
+	macMatch := re.FindAllStringSubmatch(stdoutString, 1)
+
+	if len(macMatch) != 1 {
+		return "", fmt.Errorf("MAC address for NIC: nic0 on Virtual Machine: %s not found!\n", vmName)
+	}
+
+	mac := macMatch[0][1]
+	log.Printf("Found MAC address for NIC: net0 - %s\n", mac)
+	return mac, nil
+}
+
+// Finds the IP address of a VM connected that uses DHCP by its MAC address
+func (d *Parallels9Driver) IpAddress(mac string) (string, error) {
+	var stdout bytes.Buffer
+	dhcp_lease_file := "/Library/Preferences/Parallels/parallels_dhcp_leases"
+
+	if len(mac) != 12 {
+		return "", fmt.Errorf("Not a valid MAC address: %s. It should be exactly 12 digits.", mac)
+	}
+
+	cmd := exec.Command("grep", "-i", mac, dhcp_lease_file)
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+
+	stdoutString := strings.TrimSpace(stdout.String())
+	re := regexp.MustCompile("(.*)=.*")
+	ipMatch := re.FindAllStringSubmatch(stdoutString, 1)
+
+	if len(ipMatch) != 1 {
+		return "", fmt.Errorf("IP lease not found for MAC address %s in: %s\n", mac, dhcp_lease_file)
+	}
+
+	ip := ipMatch[0][1]
+	log.Printf("Found IP lease: %s for MAC address %s\n", ip, mac)
+	return ip, nil
+}
+
+func (d *Parallels9Driver) ToolsIsoPath(k string) (string, error) {
+	appPath, err := getAppPath("com.parallels.desktop.console")
+	if err != nil {
+		return "", err
+	}
+
+	toolsPath := filepath.Join(appPath, "Contents", "Resources", "Tools", "prl-tools-"+k+".iso")
+	log.Printf("Parallels Tools path: '%s'", toolsPath)
+	return toolsPath, nil
+}
diff --git a/builder/parallels/common/driver_9_test.go b/builder/parallels/common/driver_9_test.go
new file mode 100644
index 000000000..a7c61b9d2
--- /dev/null
+++ b/builder/parallels/common/driver_9_test.go
@@ -0,0 +1,9 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestParallels9Driver_impl(t *testing.T) {
+	var _ Driver = new(Parallels9Driver)
+}
diff --git a/builder/parallels/common/driver_mock.go b/builder/parallels/common/driver_mock.go
new file mode 100644
index 000000000..25e4ea182
--- /dev/null
+++ b/builder/parallels/common/driver_mock.go
@@ -0,0 +1,124 @@
+package common
+
+import "sync"
+
+type DriverMock struct {
+	sync.Mutex
+
+	DeviceAddCdRomCalled bool
+	DeviceAddCdRomName   string
+	DeviceAddCdRomImage  string
+	DeviceAddCdRomResult string
+	DeviceAddCdRomErr    error
+
+	ImportCalled  bool
+	ImportName    string
+	ImportSrcPath string
+	ImportDstPath string
+	ImportErr     error
+
+	IsRunningName   string
+	IsRunningReturn bool
+	IsRunningErr    error
+
+	StopName string
+	StopErr  error
+
+	PrlctlCalls [][]string
+	PrlctlErrs  []error
+
+	VerifyCalled bool
+	VerifyErr    error
+
+	VersionCalled bool
+	VersionResult string
+	VersionErr    error
+
+	SendKeyScanCodesCalls [][]string
+	SendKeyScanCodesErrs  []error
+
+	ToolsIsoPathCalled bool
+	ToolsIsoPathFlavor string
+	ToolsIsoPathResult string
+	ToolsIsoPathErr    error
+
+	MacName   string
+	MacReturn string
+	MacError  error
+
+	IpAddressMac    string
+	IpAddressReturn string
+	IpAddressError  error
+}
+
+func (d *DriverMock) DeviceAddCdRom(name string, image string) (string, error) {
+	d.DeviceAddCdRomCalled = true
+	d.DeviceAddCdRomName = name
+	d.DeviceAddCdRomImage = image
+	return d.DeviceAddCdRomResult, d.DeviceAddCdRomErr
+}
+
+func (d *DriverMock) Import(name, srcPath, dstPath string, reassignMac bool) error {
+	d.ImportCalled = true
+	d.ImportName = name
+	d.ImportSrcPath = srcPath
+	d.ImportDstPath = dstPath
+	return d.ImportErr
+}
+
+func (d *DriverMock) IsRunning(name string) (bool, error) {
+	d.Lock()
+	defer d.Unlock()
+
+	d.IsRunningName = name
+	return d.IsRunningReturn, d.IsRunningErr
+}
+
+func (d *DriverMock) Stop(name string) error {
+	d.StopName = name
+	return d.StopErr
+}
+
+func (d *DriverMock) Prlctl(args ...string) error {
+	d.PrlctlCalls = append(d.PrlctlCalls, args)
+
+	if len(d.PrlctlErrs) >= len(d.PrlctlCalls) {
+		return d.PrlctlErrs[len(d.PrlctlCalls)-1]
+	}
+	return nil
+}
+
+func (d *DriverMock) Verify() error {
+	d.VerifyCalled = true
+	return d.VerifyErr
+}
+
+func (d *DriverMock) Version() (string, error) {
+	d.VersionCalled = true
+	return d.VersionResult, d.VersionErr
+}
+
+func (d *DriverMock) SendKeyScanCodes(name string, scancodes ...string) error {
+	d.SendKeyScanCodesCalls = append(d.SendKeyScanCodesCalls, scancodes)
+
+	if len(d.SendKeyScanCodesErrs) >= len(d.SendKeyScanCodesCalls) {
+		return d.SendKeyScanCodesErrs[len(d.SendKeyScanCodesCalls)-1]
+	}
+	return nil
+}
+
+func (d *DriverMock) Mac(name string) (string, error) {
+	d.MacName = name
+	return d.MacReturn, d.MacError
+}
+
+func (d *DriverMock) IpAddress(mac string) (string, error) {
+	d.IpAddressMac = mac
+	return d.IpAddressReturn, d.IpAddressError
+}
+
+func (d *DriverMock) ToolsIsoPath(flavor string) (string, error) {
+	d.ToolsIsoPathCalled = true
+	d.ToolsIsoPathFlavor = flavor
+	return d.ToolsIsoPathResult, d.ToolsIsoPathErr
+}
diff --git a/builder/parallels/common/floppy_config.go b/builder/parallels/common/floppy_config.go
new file mode 100644
index 000000000..5bcdd4b4a
--- /dev/null
+++ b/builder/parallels/common/floppy_config.go
@@ -0,0 +1,31 @@
+package common
+
+import (
+	"fmt"
+
+	"github.com/mitchellh/packer/packer"
+)
+
+// FloppyConfig is configuration related to created floppy disks and attaching
+// them to a Parallels virtual machine.
+type FloppyConfig struct {
+	FloppyFiles []string `mapstructure:"floppy_files"`
+}
+
+func (c *FloppyConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.FloppyFiles == nil {
+		c.FloppyFiles = make([]string, 0)
+	}
+
+	errs := make([]error, 0)
+	for i, file := range c.FloppyFiles {
+		var err error
+		c.FloppyFiles[i], err = t.Process(file, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf(
+				"Error processing floppy_files[%d]: %s", i, err))
+		}
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/floppy_config_test.go b/builder/parallels/common/floppy_config_test.go
new file mode 100644
index 000000000..3e4fc55db
--- /dev/null
+++ b/builder/parallels/common/floppy_config_test.go
@@ -0,0 +1,18 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestFloppyConfigPrepare(t *testing.T) {
+	c := new(FloppyConfig)
+
+	errs := c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	if len(c.FloppyFiles) > 0 {
+		t.Fatal("should not have floppy files")
+	}
+}
diff --git a/builder/parallels/common/host_ip.go b/builder/parallels/common/host_ip.go
new file mode 100644
index 000000000..c73f00349
--- /dev/null
+++ b/builder/parallels/common/host_ip.go
@@ -0,0 +1,7 @@
+package common
+
+// Interface to help find the host IP that is available from within
+// the Parallels virtual machines.
+type HostIPFinder interface {
+	HostIP() (string, error)
+}
diff --git a/builder/parallels/common/host_ip_ifconfig.go b/builder/parallels/common/host_ip_ifconfig.go
new file mode 100644
index 000000000..ff76df906
--- /dev/null
+++ b/builder/parallels/common/host_ip_ifconfig.go
@@ -0,0 +1,54 @@
+package common
+
+import (
+	"bytes"
+	"errors"
+	"os"
+	"os/exec"
+	"regexp"
+)
+
+// IfconfigIPFinder finds the host IP based on the output of `ifconfig`.
+type IfconfigIPFinder struct {
+	Devices []string
+}
+
+func (f *IfconfigIPFinder) HostIP() (string, error) {
+	var ifconfigPath string
+
+	// On some systems, ifconfig is in /sbin which is generally not
+	// on the PATH for a standard user, so we just check that first.
+	if _, err := os.Stat("/sbin/ifconfig"); err == nil {
+		ifconfigPath = "/sbin/ifconfig"
+	}
+
+	if ifconfigPath == "" {
+		var err error
+		ifconfigPath, err = exec.LookPath("ifconfig")
+		if err != nil {
+			return "", err
+		}
+	}
+
+	for _, device := range f.Devices {
+		stdout := new(bytes.Buffer)
+
+		cmd := exec.Command(ifconfigPath, device)
+		// Force LANG=C so that the output is what we expect it to be
+		// despite the locale.
+		cmd.Env = append(cmd.Env, "LANG=C")
+		cmd.Env = append(cmd.Env, os.Environ()...)
+
+		cmd.Stdout = stdout
+		cmd.Stderr = new(bytes.Buffer)
+
+		if err := cmd.Run(); err == nil {
+			re := regexp.MustCompile(`inet\s+(?:addr:)?(.+?)\s`)
+			matches := re.FindStringSubmatch(stdout.String())
+			if matches != nil {
+				return matches[1], nil
+			}
+		}
+	}
+	return "", errors.New("IP not found in ifconfig output...")
+}
diff --git a/builder/vmware/iso/host_ip_ifconfig_test.go b/builder/parallels/common/host_ip_ifconfig_test.go
similarity index 93%
rename from builder/vmware/iso/host_ip_ifconfig_test.go
rename to builder/parallels/common/host_ip_ifconfig_test.go
index 51ccc272c..a69104e69 100644
--- a/builder/vmware/iso/host_ip_ifconfig_test.go
+++ b/builder/parallels/common/host_ip_ifconfig_test.go
@@ -1,4 +1,4 @@
-package iso
+package common
 
 import "testing"
 
diff --git a/builder/parallels/common/output_config.go b/builder/parallels/common/output_config.go
new file mode 100644
index 000000000..19be1ba00
--- /dev/null
+++ b/builder/parallels/common/output_config.go
@@ -0,0 +1,40 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"os"
+)
+
+type OutputConfig struct {
+	OutputDir string `mapstructure:"output_directory"`
+}
+
+func (c *OutputConfig) Prepare(t *packer.ConfigTemplate, pc *common.PackerConfig) []error {
+	if c.OutputDir == "" {
+		c.OutputDir = fmt.Sprintf("output-%s", pc.PackerBuildName)
+	}
+
+	templates := map[string]*string{
+		"output_directory": &c.OutputDir,
+	}
+
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	if !pc.PackerForce {
+		if _, err := os.Stat(c.OutputDir); err == nil {
+			errs = append(errs, fmt.Errorf(
+				"Output directory '%s' already exists. It must not exist.", c.OutputDir))
+		}
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/output_config_test.go b/builder/parallels/common/output_config_test.go
new file mode 100644
index 000000000..7fa039a16
--- /dev/null
+++ b/builder/parallels/common/output_config_test.go
@@ -0,0 +1,65 @@
+package common
+
+import (
+	"github.com/mitchellh/packer/common"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TestOutputConfigPrepare(t *testing.T) {
+	c := new(OutputConfig)
+	if c.OutputDir != "" {
+		t.Fatalf("what: %s", c.OutputDir)
+	}
+
+	pc := &common.PackerConfig{PackerBuildName: "foo"}
+	errs := c.Prepare(testConfigTemplate(t), pc)
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	if c.OutputDir == "" {
+		t.Fatal("should have output dir")
+	}
+}
+
+func TestOutputConfigPrepare_exists(t *testing.T) {
+	td, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.RemoveAll(td)
+
+	c := new(OutputConfig)
+	c.OutputDir = td
+
+	pc := &common.PackerConfig{
+		PackerBuildName: "foo",
+		PackerForce:     false,
+	}
+	errs := c.Prepare(testConfigTemplate(t), pc)
+	if len(errs) == 0 {
+		t.Fatal("should have errors")
+	}
+}
+
+func TestOutputConfigPrepare_forceExists(t *testing.T) {
+	td, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.RemoveAll(td)
+
+	c := new(OutputConfig)
+	c.OutputDir = td
+
+	pc := &common.PackerConfig{
+		PackerBuildName: "foo",
+		PackerForce:     true,
+	}
+	errs := c.Prepare(testConfigTemplate(t), pc)
+	if len(errs) > 0 {
+		t.Fatal("should not have errors")
+	}
+}
diff --git a/builder/parallels/common/prlctl_config.go b/builder/parallels/common/prlctl_config.go
new file mode 100644
index 000000000..eff0618b3
--- /dev/null
+++ b/builder/parallels/common/prlctl_config.go
@@ -0,0 +1,28 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+)
+
+type PrlctlConfig struct {
+	Prlctl [][]string `mapstructure:"prlctl"`
+}
+
+func (c *PrlctlConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.Prlctl == nil {
+		c.Prlctl = make([][]string, 0)
+	}
+
+	errs := make([]error, 0)
+	for i, args := range c.Prlctl {
+		for j, arg := range args {
+			if err := t.Validate(arg); err != nil {
+				errs = append(errs,
+					fmt.Errorf("Error processing prlctl[%d][%d]: %s", i, j, err))
+			}
+		}
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/prlctl_config_test.go b/builder/parallels/common/prlctl_config_test.go
new file mode 100644
index 000000000..cafb3d23c
--- /dev/null
+++ b/builder/parallels/common/prlctl_config_test.go
@@ -0,0 +1,37 @@
+package common
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestPrlctlConfigPrepare_Prlctl(t *testing.T) {
+	// Test with empty
+	c := new(PrlctlConfig)
+	errs := c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	if !reflect.DeepEqual(c.Prlctl, [][]string{}) {
+		t.Fatalf("bad: %#v", c.Prlctl)
+	}
+
+	// Test with a good one
+	c = new(PrlctlConfig)
+	c.Prlctl = [][]string{
+		{"foo", "bar", "baz"},
+	}
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	expected := [][]string{
+		[]string{"foo", "bar", "baz"},
+	}
+
+	if !reflect.DeepEqual(c.Prlctl, expected) {
+		t.Fatalf("bad: %#v", c.Prlctl)
+	}
+}
diff --git a/builder/parallels/common/prlctl_version_config.go b/builder/parallels/common/prlctl_version_config.go
new file mode 100644
index 000000000..2103d9a59
--- /dev/null
+++ b/builder/parallels/common/prlctl_version_config.go
@@ -0,0 +1,31 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+)
+
+type PrlctlVersionConfig struct {
+	PrlctlVersionFile string `mapstructure:"prlctl_version_file"`
+}
+
+func (c *PrlctlVersionConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.PrlctlVersionFile == "" {
+		c.PrlctlVersionFile = ".prlctl_version"
+	}
+
+	templates := map[string]*string{
+		"prlctl_version_file": &c.PrlctlVersionFile,
+	}
+
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/prlctl_version_config_test.go b/builder/parallels/common/prlctl_version_config_test.go
new file mode 100644
index 000000000..daf934a16
--- /dev/null
+++ b/builder/parallels/common/prlctl_version_config_test.go
@@ -0,0 +1,33 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestPrlctlVersionConfigPrepare_BootWait(t *testing.T) {
+	var c *PrlctlVersionConfig
+	var errs []error
+
+	// Test empty
+	c = new(PrlctlVersionConfig)
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %s", errs)
+	}
+
+	if c.PrlctlVersionFile != ".prlctl_version" {
+		t.Fatalf("bad value: %s", c.PrlctlVersionFile)
+	}
+
+	// Test with a good one
+	c = new(PrlctlVersionConfig)
+	c.PrlctlVersionFile = "foo"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %s", errs)
+	}
+
+	if c.PrlctlVersionFile != "foo" {
+		t.Fatalf("bad value: %s", c.PrlctlVersionFile)
+	}
+}
diff --git a/builder/parallels/common/prltype.go b/builder/parallels/common/prltype.go
new file mode 100644
index 000000000..bd99e0a13
--- /dev/null
+++ b/builder/parallels/common/prltype.go
@@ -0,0 +1,76 @@
+package common
+
+const Prltype string = `
+import sys
+import prlsdkapi
+
+##
+def main():
+    if len(sys.argv) < 3:
+       print "Usage: prltype VM_NAME SCANCODE..."
+       sys.exit(1)
+
+    vm_name = sys.argv[1]
+    scancodes = sys.argv[2:]
+
+    server = login()
+    vm, vm_io = connect(server, vm_name)
+
+    send(scancodes, vm, vm_io)
+
+    disconnect(server, vm, vm_io)
+
+##
+def login():
+    prlsdkapi.prlsdk.InitializeSDK(prlsdkapi.prlsdk.consts.PAM_DESKTOP_MAC)
+    server = prlsdkapi.Server()
+    login_job=server.login_local()
+    login_job.wait()
+
+    return server
+
+##
+def connect(server, vm_name):
+    vm_list_job = server.get_vm_list()
+    result = vm_list_job.wait()
+
+    vm_list = [result.get_param_by_index(i) for i in range(result.get_params_count())]
+    vm = [vm for vm in vm_list if vm.get_name() == vm_name]
+
+    if not vm:
+       vm_names = [vm.get_name() for vm in vm_list]
+       raise Exception("%s: No such VM. Available VM's are:\n%s" % (vm_name, "\n".join(vm_names)))
+
+    vm = vm[0]
+
+    vm_io = prlsdkapi.VmIO()
+    vm_io.connect_to_vm(vm).wait()
+
+    return (vm, vm_io)
+
+##
+def disconnect(server, vm, vm_io):
+    if vm and vm_io:
+        vm_io.disconnect_from_vm(vm)
+
+    if server:
+        server.logoff()
+
+    prlsdkapi.deinit_sdk
+
+##
+def send(scancodes, vm, vm_io):
+    timeout = 10
+    consts = prlsdkapi.prlsdk.consts
+
+    for scancode in scancodes:
+        c = int(scancode, 16)
+        if (c < 128):
+            vm_io.send_key_event(vm, (c,), consts.PKE_PRESS, timeout)
+        else:
+            vm_io.send_key_event(vm, (c - 128,) , consts.PKE_RELEASE, timeout)
+
+##
+if __name__ == "__main__":
+    main()
+`
diff --git a/builder/parallels/common/run_config.go b/builder/parallels/common/run_config.go
new file mode 100644
index 000000000..755d0f1c1
--- /dev/null
+++ b/builder/parallels/common/run_config.go
@@ -0,0 +1,41 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+	"time"
+)
+
+type RunConfig struct {
+	Headless    bool   `mapstructure:"headless"`
+	RawBootWait string `mapstructure:"boot_wait"`
+
+	BootWait time.Duration ``
+}
+
+func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.RawBootWait == "" {
+		c.RawBootWait = "10s"
+	}
+
+	templates := map[string]*string{
+		"boot_wait": &c.RawBootWait,
+	}
+
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	var err error
+	c.BootWait, err = time.ParseDuration(c.RawBootWait)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/run_config_test.go b/builder/parallels/common/run_config_test.go
new file mode 100644
index 000000000..8068fe625
--- /dev/null
+++ b/builder/parallels/common/run_config_test.go
@@ -0,0 +1,37 @@
+package common
+
+import (
+	"testing"
+)
+
+func TestRunConfigPrepare_BootWait(t *testing.T) {
+	var c *RunConfig
+	var errs []error
+
+	// Test a default boot_wait
+	c = new(RunConfig)
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %s", errs)
+	}
+
+	if c.RawBootWait != "10s" {
+		t.Fatalf("bad value: %s", c.RawBootWait)
+	}
+
+	// Test with a bad boot_wait
+	c = new(RunConfig)
+	c.RawBootWait = "this is not good"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatalf("bad: %#v", errs)
+	}
+
+	// Test with a good one
+	c = new(RunConfig)
+	c.RawBootWait = "5s"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %s", errs)
+	}
+}
diff --git a/builder/parallels/common/shutdown_config.go b/builder/parallels/common/shutdown_config.go
new file mode 100644
index 000000000..05e5fdfeb
--- /dev/null
+++ b/builder/parallels/common/shutdown_config.go
@@ -0,0 +1,42 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+	"time"
+)
+
+type ShutdownConfig struct {
+	ShutdownCommand    string `mapstructure:"shutdown_command"`
+	RawShutdownTimeout string `mapstructure:"shutdown_timeout"`
+
+	ShutdownTimeout time.Duration ``
+}
+
+func (c *ShutdownConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.RawShutdownTimeout == "" {
+		c.RawShutdownTimeout = "5m"
+	}
+
+	templates := map[string]*string{
+		"shutdown_command": &c.ShutdownCommand,
+		"shutdown_timeout": &c.RawShutdownTimeout,
+	}
+
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	var err error
+	c.ShutdownTimeout, err = time.ParseDuration(c.RawShutdownTimeout)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed parsing shutdown_timeout: %s", err))
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/shutdown_config_test.go b/builder/parallels/common/shutdown_config_test.go
new file mode 100644
index 000000000..5da613a19
--- /dev/null
+++ b/builder/parallels/common/shutdown_config_test.go
@@ -0,0 +1,45 @@
+package common
+
+import (
+	"testing"
+	"time"
+)
+
+func testShutdownConfig() *ShutdownConfig {
+	return &ShutdownConfig{}
+}
+
+func TestShutdownConfigPrepare_ShutdownCommand(t *testing.T) {
+	var c *ShutdownConfig
+	var errs []error
+
+	c = testShutdownConfig()
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+}
+
+func TestShutdownConfigPrepare_ShutdownTimeout(t *testing.T) {
+	var c *ShutdownConfig
+	var errs []error
+
+	// Test with a bad value
+	c = testShutdownConfig()
+	c.RawShutdownTimeout = "this is not good"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatalf("should have error")
+	}
+
+	// Test with a good one
+	c = testShutdownConfig()
+	c.RawShutdownTimeout = "5s"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+	if c.ShutdownTimeout != 5*time.Second {
+		t.Fatalf("bad: %s", c.ShutdownTimeout)
+	}
+}
diff --git a/builder/parallels/common/ssh.go b/builder/parallels/common/ssh.go
new file mode 100644
index 000000000..e914583c1
--- /dev/null
+++ b/builder/parallels/common/ssh.go
@@ -0,0 +1,51 @@
+package common
+
+import (
+	"fmt"
+
+	"code.google.com/p/go.crypto/ssh"
+	"github.com/mitchellh/multistep"
+	commonssh "github.com/mitchellh/packer/common/ssh"
+	packerssh "github.com/mitchellh/packer/communicator/ssh"
+)
+
+func SSHAddress(state multistep.StateBag) (string, error) {
+	vmName := state.Get("vmName").(string)
+	driver := state.Get("driver").(Driver)
+
+	mac, err := driver.Mac(vmName)
+	if err != nil {
+		return "", err
+	}
+
+	ip, err := driver.IpAddress(mac)
+	if err != nil {
+		return "", err
+	}
+
+	return fmt.Sprintf("%s:22", ip), nil
+}
+
+func SSHConfigFunc(config SSHConfig) func(multistep.StateBag) (*ssh.ClientConfig, error) {
+	return func(state multistep.StateBag) (*ssh.ClientConfig, error) {
+		auth := []ssh.AuthMethod{
+			ssh.Password(config.SSHPassword),
+			ssh.KeyboardInteractive(
+				packerssh.PasswordKeyboardInteractive(config.SSHPassword)),
+		}
+
+		if config.SSHKeyPath != "" {
+			signer, err := commonssh.FileSigner(config.SSHKeyPath)
+			if err != nil {
+				return nil, err
+			}
+
+			auth = append(auth, ssh.PublicKeys(signer))
+		}
+
+		return &ssh.ClientConfig{
+			User: config.SSHUser,
+			Auth: auth,
+		}, nil
+	}
+}
diff --git a/builder/parallels/common/ssh_config.go b/builder/parallels/common/ssh_config.go
new file mode 100644
index 000000000..d89daa103
--- /dev/null
+++ b/builder/parallels/common/ssh_config.go
@@ -0,0 +1,67 @@
+package common
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"time"
+
+	commonssh "github.com/mitchellh/packer/common/ssh"
+	"github.com/mitchellh/packer/packer"
+)
+
+type SSHConfig struct {
+	SSHKeyPath        string `mapstructure:"ssh_key_path"`
+	SSHPassword       string `mapstructure:"ssh_password"`
+	SSHPort           uint   `mapstructure:"ssh_port"`
+	SSHUser           string `mapstructure:"ssh_username"`
+	RawSSHWaitTimeout string `mapstructure:"ssh_wait_timeout"`
+
+	SSHWaitTimeout time.Duration
+}
+
+func (c *SSHConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.SSHPort == 0 {
+		c.SSHPort = 22
+	}
+
+	if c.RawSSHWaitTimeout == "" {
+		c.RawSSHWaitTimeout = "20m"
+	}
+
+	templates := map[string]*string{
+		"ssh_key_path":     &c.SSHKeyPath,
+		"ssh_password":     &c.SSHPassword,
+		"ssh_username":     &c.SSHUser,
+		"ssh_wait_timeout": &c.RawSSHWaitTimeout,
+	}
+
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	if c.SSHKeyPath != "" {
+		if _, err := os.Stat(c.SSHKeyPath); err != nil {
+			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
+		} else if _, err := commonssh.FileSigner(c.SSHKeyPath); err != nil {
+			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
+		}
+	}
+
+	if c.SSHUser == "" {
+		errs = append(errs, errors.New("An ssh_username must be specified."))
+	}
+
+	var err error
+	c.SSHWaitTimeout, err = time.ParseDuration(c.RawSSHWaitTimeout)
+	if err != nil {
+		errs = append(errs, fmt.Errorf("Failed parsing ssh_wait_timeout: %s", err))
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/ssh_config_test.go b/builder/parallels/common/ssh_config_test.go
new file mode 100644
index 000000000..a6c9e8ef5
--- /dev/null
+++ b/builder/parallels/common/ssh_config_test.go
@@ -0,0 +1,155 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func testSSHConfig() *SSHConfig {
+	return &SSHConfig{
+		SSHUser: "foo",
+	}
+}
+
+func TestSSHConfigPrepare(t *testing.T) {
+	c := testSSHConfig()
+	errs := c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	if c.SSHPort != 22 {
+		t.Errorf("bad ssh port: %d", c.SSHPort)
+	}
+}
+
+func TestSSHConfigPrepare_SSHKeyPath(t *testing.T) {
+	var c *SSHConfig
+	var errs []error
+
+	c = testSSHConfig()
+	c.SSHKeyPath = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+
+	c = testSSHConfig()
+	c.SSHKeyPath = "/i/dont/exist"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+
+	// Test bad contents
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.Remove(tf.Name())
+	defer tf.Close()
+
+	if _, err := tf.Write([]byte("HELLO!")); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	c = testSSHConfig()
+	c.SSHKeyPath = tf.Name()
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+
+	// Test good contents
+	tf.Seek(0, 0)
+	tf.Truncate(0)
+	tf.Write([]byte(testPem))
+	c = testSSHConfig()
+	c.SSHKeyPath = tf.Name()
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+}
+
+func TestSSHConfigPrepare_SSHUser(t *testing.T) {
+	var c *SSHConfig
+	var errs []error
+
+	c = testSSHConfig()
+	c.SSHUser = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatalf("should have error")
+	}
+
+	c = testSSHConfig()
+	c.SSHUser = "exists"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+}
+
+func TestSSHConfigPrepare_SSHWaitTimeout(t *testing.T) {
+	var c *SSHConfig
+	var errs []error
+
+	// Defaults
+	c = testSSHConfig()
+	c.RawSSHWaitTimeout = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+	if c.RawSSHWaitTimeout != "20m" {
+		t.Fatalf("bad value: %s", c.RawSSHWaitTimeout)
+	}
+
+	// Test with a bad value
+	c = testSSHConfig()
+	c.RawSSHWaitTimeout = "this is not good"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+
+	// Test with a good one
+	c = testSSHConfig()
+	c.RawSSHWaitTimeout = "5s"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+}
+
+const testPem = `
+-----BEGIN RSA PRIVATE KEY-----
+MIIEpQIBAAKCAQEAxd4iamvrwRJvtNDGQSIbNvvIQN8imXTRWlRY62EvKov60vqu
+hh+rDzFYAIIzlmrJopvOe0clqmi3mIP9dtkjPFrYflq52a2CF5q+BdwsJXuRHbJW
+LmStZUwW1khSz93DhvhmK50nIaczW63u4EO/jJb3xj+wxR1Nkk9bxi3DDsYFt8SN
+AzYx9kjlEYQ/+sI4/ATfmdV9h78SVotjScupd9KFzzi76gWq9gwyCBLRynTUWlyD
+2UOfJRkOvhN6/jKzvYfVVwjPSfA9IMuooHdScmC4F6KBKJl/zf/zETM0XyzIDNmH
+uOPbCiljq2WoRM+rY6ET84EO0kVXbfx8uxUsqQIDAQABAoIBAQCkPj9TF0IagbM3
+5BSs/CKbAWS4dH/D4bPlxx4IRCNirc8GUg+MRb04Xz0tLuajdQDqeWpr6iLZ0RKV
+BvreLF+TOdV7DNQ4XE4gSdJyCtCaTHeort/aordL3l0WgfI7mVk0L/yfN1PEG4YG
+E9q1TYcyrB3/8d5JwIkjabxERLglCcP+geOEJp+QijbvFIaZR/n2irlKW4gSy6ko
+9B0fgUnhkHysSg49ChHQBPQ+o5BbpuLrPDFMiTPTPhdfsvGGcyCGeqfBA56oHcSF
+K02Fg8OM+Bd1lb48LAN9nWWY4WbwV+9bkN3Ym8hO4c3a/Dxf2N7LtAQqWZzFjvM3
+/AaDvAgBAoGBAPLD+Xn1IYQPMB2XXCXfOuJewRY7RzoVWvMffJPDfm16O7wOiW5+
+2FmvxUDayk4PZy6wQMzGeGKnhcMMZTyaq2g/QtGfrvy7q1Lw2fB1VFlVblvqhoJa
+nMJojjC4zgjBkXMHsRLeTmgUKyGs+fdFbfI6uejBnnf+eMVUMIdJ+6I9AoGBANCn
+kWO9640dttyXURxNJ3lBr2H3dJOkmD6XS+u+LWqCSKQe691Y/fZ/ZL0Oc4Mhy7I6
+hsy3kDQ5k2V0fkaNODQIFJvUqXw2pMewUk8hHc9403f4fe9cPrL12rQ8WlQw4yoC
+v2B61vNczCCUDtGxlAaw8jzSRaSI5s6ax3K7enbdAoGBAJB1WYDfA2CoAQO6y9Sl
+b07A/7kQ8SN5DbPaqrDrBdJziBQxukoMJQXJeGFNUFD/DXFU5Fp2R7C86vXT7HIR
+v6m66zH+CYzOx/YE6EsUJms6UP9VIVF0Rg/RU7teXQwM01ZV32LQ8mswhTH20o/3
+uqMHmxUMEhZpUMhrfq0isyApAoGAe1UxGTXfj9AqkIVYylPIq2HqGww7+jFmVEj1
+9Wi6S6Sq72ffnzzFEPkIQL/UA4TsdHMnzsYKFPSbbXLIWUeMGyVTmTDA5c0e5XIR
+lPhMOKCAzv8w4VUzMnEkTzkFY5JqFCD/ojW57KvDdNZPVB+VEcdxyAW6aKELXMAc
+eHLc1nkCgYEApm/motCTPN32nINZ+Vvywbv64ZD+gtpeMNP3CLrbe1X9O+H52AXa
+1jCoOldWR8i2bs2NVPcKZgdo6fFULqE4dBX7Te/uYEIuuZhYLNzRO1IKU/YaqsXG
+3bfQ8hKYcSnTfE0gPtLDnqCIxTocaGLSHeG3TH9fTw+dA8FvWpUztI4=
+-----END RSA PRIVATE KEY-----
+`
diff --git a/builder/parallels/common/step_attach_floppy.go b/builder/parallels/common/step_attach_floppy.go
new file mode 100644
index 000000000..0e8fba021
--- /dev/null
+++ b/builder/parallels/common/step_attach_floppy.go
@@ -0,0 +1,78 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+// This step attaches a floppy to the virtual machine.
+//
+// Uses:
+//   driver Driver
+//   ui packer.Ui
+//   vmName string
+//
+// Produces:
+type StepAttachFloppy struct {
+	floppyPath string
+}
+
+func (s *StepAttachFloppy) Run(state multistep.StateBag) multistep.StepAction {
+	// Determine if we even have a floppy disk to attach
+	var floppyPath string
+	if floppyPathRaw, ok := state.GetOk("floppy_path"); ok {
+		floppyPath = floppyPathRaw.(string)
+	} else {
+		log.Println("No floppy disk, not attaching.")
+		return multistep.ActionContinue
+	}
+
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	ui.Say("Deleting any current floppy disk...")
+	// Delete the floppy disk controller
+	del_command := []string{
+		"set", vmName,
+		"--device-del", "fdd0",
+	}
+	// This will almost certainly fail with 'The fdd0 device does not exist.'
+	driver.Prlctl(del_command...)
+
+	ui.Say("Attaching floppy disk...")
+	// Attaching the floppy disk
+	add_command := []string{
+		"set", vmName,
+		"--device-add", "fdd",
+		"--image", floppyPath,
+		"--connect",
+	}
+	if err := driver.Prlctl(add_command...); err != nil {
+		state.Put("error", fmt.Errorf("Error adding floppy: %s", err))
+		return multistep.ActionHalt
+	}
+
+	// Track the path so that we can unregister it from Parallels later
+	s.floppyPath = floppyPath
+
+	return multistep.ActionContinue
+}
+
+func (s *StepAttachFloppy) Cleanup(state multistep.StateBag) {
+	driver := state.Get("driver").(Driver)
+	vmName := state.Get("vmName").(string)
+
+	if s.floppyPath == "" {
+		return
+	}
+
+	log.Println("Detaching floppy disk...")
+	command := []string{
+		"set", vmName,
+		"--device-del", "fdd0",
+	}
+	driver.Prlctl(command...)
+}
diff --git a/builder/parallels/common/step_attach_floppy_test.go b/builder/parallels/common/step_attach_floppy_test.go
new file mode 100644
index 000000000..790eadc1b
--- /dev/null
+++ b/builder/parallels/common/step_attach_floppy_test.go
@@ -0,0 +1,84 @@
+package common
+
+import (
+	"github.com/mitchellh/multistep"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func TestStepAttachFloppy_impl(t *testing.T) {
+	var _ multistep.Step = new(StepAttachFloppy)
+}
+
+func TestStepAttachFloppy(t *testing.T) {
+	state := testState(t)
+	step := new(StepAttachFloppy)
+
+	// Create a temporary file for our floppy file
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	tf.Close()
+	defer os.Remove(tf.Name())
+
+	state.Put("floppy_path", tf.Name())
+	state.Put("vmName", "foo")
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	if len(driver.PrlctlCalls) != 2 {
+		t.Fatal("not enough calls to prlctl")
+	}
+
+	if driver.PrlctlCalls[0][0] != "set" {
+		t.Fatal("bad call")
+	}
+	if driver.PrlctlCalls[0][2] != "--device-del" {
+		t.Fatal("bad call")
+	}
+	if driver.PrlctlCalls[0][3] != "fdd0" {
+		t.Fatal("bad call")
+	}
+
+	if driver.PrlctlCalls[1][0] != "set" {
+		t.Fatal("bad call")
+	}
+	if driver.PrlctlCalls[1][2] != "--device-add" {
+		t.Fatal("bad call")
+	}
+	if driver.PrlctlCalls[1][3] != "fdd" {
+		t.Fatal("bad call")
+	}
+	if driver.PrlctlCalls[1][6] != "--connect" {
+		t.Fatal("bad call")
+	}
+}
+
+func TestStepAttachFloppy_noFloppy(t *testing.T) {
+	state := testState(t)
+	step := new(StepAttachFloppy)
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	if len(driver.PrlctlCalls) > 0 {
+		t.Fatal("should not call prlctl")
+	}
+}
diff --git a/builder/parallels/common/step_attach_parallels_tools.go b/builder/parallels/common/step_attach_parallels_tools.go
new file mode 100644
index 000000000..f681a83f1
--- /dev/null
+++ b/builder/parallels/common/step_attach_parallels_tools.go
@@ -0,0 +1,76 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+// This step attaches the Parallels Tools as an inserted CD onto
+// the virtual machine.
+//
+// Uses:
+//   driver Driver
+//   parallels_tools_path string
+//   ui packer.Ui
+//   vmName string
+//
+// Produces:
+type StepAttachParallelsTools struct {
+	cdromDevice        string
+	ParallelsToolsMode string
+}
+
+func (s *StepAttachParallelsTools) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	// If we're not attaching the guest additions then just return
+	if s.ParallelsToolsMode != ParallelsToolsModeAttach {
+		log.Println("Not attaching parallels tools since we're uploading.")
+		return multistep.ActionContinue
+	}
+
+	// Get the Paralells Tools path on the host machine
+	parallelsToolsPath := state.Get("parallels_tools_path").(string)
+
+	// Attach the guest additions to the computer
+	ui.Say("Attaching Parallels Tools ISO to the new CD/DVD drive...")
+
+	cdrom, err := driver.DeviceAddCdRom(vmName, parallelsToolsPath)
+
+	if err != nil {
+		err := fmt.Errorf("Error attaching Parallels Tools ISO: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Track the device name so that we can can delete later
+	s.cdromDevice = cdrom
+
+	return multistep.ActionContinue
+}
+
+func (s *StepAttachParallelsTools) Cleanup(state multistep.StateBag) {
+	if s.cdromDevice == "" {
+		return
+	}
+
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	log.Println("Detaching Parallels Tools ISO...")
+
+	command := []string{
+		"set", vmName,
+		"--device-del", s.cdromDevice,
+	}
+
+	if err := driver.Prlctl(command...); err != nil {
+		ui.Error(fmt.Sprintf("Error detaching Parallels Tools ISO: %s", err))
+	}
+}
diff --git a/builder/parallels/common/step_output_dir.go b/builder/parallels/common/step_output_dir.go
new file mode 100644
index 000000000..0c7c04d15
--- /dev/null
+++ b/builder/parallels/common/step_output_dir.go
@@ -0,0 +1,73 @@
+package common
+
+import (
+	"fmt"
+	"log"
+	"os"
+	"path/filepath"
+	"time"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+// StepOutputDir sets up the output directory by creating it if it does
+// not exist, deleting it if it does exist and we're forcing, and cleaning
+// it up when we're done with it.
+type StepOutputDir struct {
+	Force   bool
+	Path    string
+	success bool
+}
+
+func (s *StepOutputDir) Run(state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
+
+	if _, err := os.Stat(s.Path); err == nil && s.Force {
+		ui.Say("Deleting previous output directory...")
+		os.RemoveAll(s.Path)
+	}
+
+	// Create the directory
+	if err := os.MkdirAll(s.Path, 0755); err != nil {
+		state.Put("error", err)
+		return multistep.ActionHalt
+	}
+
+	// Make sure we can write in the directory
+	f, err := os.Create(filepath.Join(s.Path, "_packer_perm_check"))
+	if err != nil {
+		err = fmt.Errorf("Couldn't write to output directory: %s", err)
+		state.Put("error", err)
+		return multistep.ActionHalt
+	}
+	f.Close()
+	os.Remove(f.Name())
+
+	s.success = true
+	return multistep.ActionContinue
+}
+
+func (s *StepOutputDir) Cleanup(state multistep.StateBag) {
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	_, halted := state.GetOk(multistep.StateHalted)
+
+	if !s.success {
+		return
+	}
+
+	if cancelled || halted {
+		ui := state.Get("ui").(packer.Ui)
+
+		ui.Say("Deleting output directory...")
+		for i := 0; i < 5; i++ {
+			err := os.RemoveAll(s.Path)
+			if err == nil {
+				break
+			}
+
+			log.Printf("Error removing output dir: %s", err)
+			time.Sleep(2 * time.Second)
+		}
+	}
+}
diff --git a/builder/parallels/common/step_output_dir_test.go b/builder/parallels/common/step_output_dir_test.go
new file mode 100644
index 000000000..be485c278
--- /dev/null
+++ b/builder/parallels/common/step_output_dir_test.go
@@ -0,0 +1,96 @@
+package common
+
+import (
+	"github.com/mitchellh/multistep"
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func testStepOutputDir(t *testing.T) *StepOutputDir {
+	td, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	if err := os.RemoveAll(td); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return &StepOutputDir{Force: false, Path: td}
+}
+
+func TestStepOutputDir_impl(t *testing.T) {
+	var _ multistep.Step = new(StepOutputDir)
+}
+
+func TestStepOutputDir(t *testing.T) {
+	state := testState(t)
+	step := testStepOutputDir(t)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+	if _, err := os.Stat(step.Path); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Test the cleanup
+	step.Cleanup(state)
+	if _, err := os.Stat(step.Path); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestStepOutputDir_cancelled(t *testing.T) {
+	state := testState(t)
+	step := testStepOutputDir(t)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+	if _, err := os.Stat(step.Path); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Mark
+	state.Put(multistep.StateCancelled, true)
+
+	// Test the cleanup
+	step.Cleanup(state)
+	if _, err := os.Stat(step.Path); err == nil {
+		t.Fatal("should not exist")
+	}
+}
+
+func TestStepOutputDir_halted(t *testing.T) {
+	state := testState(t)
+	step := testStepOutputDir(t)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+	if _, err := os.Stat(step.Path); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Mark
+	state.Put(multistep.StateHalted, true)
+
+	// Test the cleanup
+	step.Cleanup(state)
+	if _, err := os.Stat(step.Path); err == nil {
+		t.Fatal("should not exist")
+	}
+}
diff --git a/builder/parallels/common/step_prepare_parallels_tools.go b/builder/parallels/common/step_prepare_parallels_tools.go
new file mode 100644
index 000000000..752268fd7
--- /dev/null
+++ b/builder/parallels/common/step_prepare_parallels_tools.go
@@ -0,0 +1,47 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"os"
+)
+
+// This step prepares parameters related to Parallels Tools.
+//
+// Uses:
+//   driver Driver
+//
+// Produces:
+//   parallels_tools_path string
+type StepPrepareParallelsTools struct {
+	ParallelsToolsFlavor string
+	ParallelsToolsMode   string
+}
+
+func (s *StepPrepareParallelsTools) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
+
+	if s.ParallelsToolsMode == ParallelsToolsModeDisable {
+		return multistep.ActionContinue
+	}
+
+	path, err := driver.ToolsIsoPath(s.ParallelsToolsFlavor)
+
+	if err != nil {
+		state.Put("error", err)
+		return multistep.ActionHalt
+	}
+
+	if _, err := os.Stat(path); err != nil {
+		state.Put("error", fmt.Errorf(
+			"Couldn't find Parallels Tools for the '%s' flavor! Please, check the\n"+
+				"value of 'parallels_tools_flavor'. Valid flavors are: 'win', 'lin',\n"+
+				"'mac', 'os2' and 'other'", s.ParallelsToolsFlavor))
+		return multistep.ActionHalt
+	}
+
+	state.Put("parallels_tools_path", path)
+	return multistep.ActionContinue
+}
+
+func (s *StepPrepareParallelsTools) Cleanup(multistep.StateBag) {}
diff --git a/builder/parallels/common/step_prepare_parallels_tools_test.go b/builder/parallels/common/step_prepare_parallels_tools_test.go
new file mode 100644
index 000000000..931ecb972
--- /dev/null
+++ b/builder/parallels/common/step_prepare_parallels_tools_test.go
@@ -0,0 +1,115 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/mitchellh/multistep"
+)
+
+func TestStepPrepareParallelsTools_impl(t *testing.T) {
+	var _ multistep.Step = new(StepPrepareParallelsTools)
+}
+
+func TestStepPrepareParallelsTools(t *testing.T) {
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	tf.Close()
+	defer os.Remove(tf.Name())
+
+	state := testState(t)
+	step := &StepPrepareParallelsTools{
+		ParallelsToolsMode:   "",
+		ParallelsToolsFlavor: "foo",
+	}
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Mock results
+	driver.ToolsIsoPathResult = tf.Name()
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test the driver
+	if !driver.ToolsIsoPathCalled {
+		t.Fatal("tools iso path should be called")
+	}
+	if driver.ToolsIsoPathFlavor != "foo" {
+		t.Fatalf("bad: %#v", driver.ToolsIsoPathFlavor)
+	}
+
+	// Test the resulting state
+	path, ok := state.GetOk("parallels_tools_path")
+	if !ok {
+		t.Fatal("should have parallels_tools_path")
+	}
+	if path != tf.Name() {
+		t.Fatalf("bad: %#v", path)
+	}
+}
+
+func TestStepPrepareParallelsTools_disabled(t *testing.T) {
+	state := testState(t)
+	step := &StepPrepareParallelsTools{
+		ParallelsToolsFlavor: "foo",
+		ParallelsToolsMode:   ParallelsToolsModeDisable,
+	}
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test the driver
+	if driver.ToolsIsoPathCalled {
+		t.Fatal("tools iso path should NOT be called")
+	}
+}
+
+func TestStepPrepareParallelsTools_nonExist(t *testing.T) {
+	state := testState(t)
+	step := &StepPrepareParallelsTools{
+		ParallelsToolsFlavor: "foo",
+		ParallelsToolsMode:   "",
+	}
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Mock results
+	driver.ToolsIsoPathResult = "foo"
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionHalt {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); !ok {
+		t.Fatal("should have error")
+	}
+
+	// Test the driver
+	if !driver.ToolsIsoPathCalled {
+		t.Fatal("tools iso path should be called")
+	}
+	if driver.ToolsIsoPathFlavor != "foo" {
+		t.Fatalf("bad: %#v", driver.ToolsIsoPathFlavor)
+	}
+
+	// Test the resulting state
+	if _, ok := state.GetOk("parallels_tools_path"); ok {
+		t.Fatal("should NOT have parallels_tools_path")
+	}
+}
diff --git a/builder/parallels/common/step_prlctl.go b/builder/parallels/common/step_prlctl.go
new file mode 100644
index 000000000..9bd7c4b73
--- /dev/null
+++ b/builder/parallels/common/step_prlctl.go
@@ -0,0 +1,68 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"strings"
+)
+
+type commandTemplate struct {
+	Name string
+}
+
+// This step executes additional prlctl commands as specified by the
+// template.
+//
+// Uses:
+//   driver Driver
+//   ui packer.Ui
+//   vmName string
+//
+// Produces:
+type StepPrlctl struct {
+	Commands [][]string
+	Tpl      *packer.ConfigTemplate
+}
+
+func (s *StepPrlctl) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	if len(s.Commands) > 0 {
+		ui.Say("Executing custom prlctl commands...")
+	}
+
+	tplData := &commandTemplate{
+		Name: vmName,
+	}
+
+	for _, originalCommand := range s.Commands {
+		command := make([]string, len(originalCommand))
+		copy(command, originalCommand)
+
+		for i, arg := range command {
+			var err error
+			command[i], err = s.Tpl.Process(arg, tplData)
+			if err != nil {
+				err := fmt.Errorf("Error preparing prlctl command: %s", err)
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			}
+		}
+
+		ui.Message(fmt.Sprintf("Executing: prlctl %s", strings.Join(command, " ")))
+		if err := driver.Prlctl(command...); err != nil {
+			err := fmt.Errorf("Error executing command: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepPrlctl) Cleanup(state multistep.StateBag) {}
diff --git a/builder/parallels/common/step_run.go b/builder/parallels/common/step_run.go
new file mode 100644
index 000000000..e9c3ab27d
--- /dev/null
+++ b/builder/parallels/common/step_run.go
@@ -0,0 +1,80 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"time"
+)
+
+// This step starts the virtual machine.
+//
+// Uses:
+//   driver Driver
+//   ui packer.Ui
+//   vmName string
+//
+// Produces:
+type StepRun struct {
+	BootWait time.Duration
+	Headless bool
+
+	vmName string
+}
+
+func (s *StepRun) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	ui.Say("Starting the virtual machine...")
+	//guiArgument := "gui"
+	if s.Headless == true {
+		ui.Message("WARNING: The VM will be started in headless mode, as configured.\n" +
+			"In headless mode, errors during the boot sequence or OS setup\n" +
+			"won't be easily visible. Use at your own discretion.")
+		//guiArgument = "headless"
+	}
+	command := []string{"start", vmName}
+	if err := driver.Prlctl(command...); err != nil {
+		err := fmt.Errorf("Error starting VM: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	s.vmName = vmName
+
+	if int64(s.BootWait) > 0 {
+		ui.Say(fmt.Sprintf("Waiting %s for boot...", s.BootWait))
+		wait := time.After(s.BootWait)
+	WAITLOOP:
+		for {
+			select {
+			case <-wait:
+				break WAITLOOP
+			case <-time.After(1 * time.Second):
+				if _, ok := state.GetOk(multistep.StateCancelled); ok {
+					return multistep.ActionHalt
+				}
+			}
+		}
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepRun) Cleanup(state multistep.StateBag) {
+	if s.vmName == "" {
+		return
+	}
+
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+
+	if running, _ := driver.IsRunning(s.vmName); running {
+		if err := driver.Prlctl("stop", s.vmName); err != nil {
+			ui.Error(fmt.Sprintf("Error stopping VM: %s", err))
+		}
+	}
+}
diff --git a/builder/parallels/common/step_shutdown.go b/builder/parallels/common/step_shutdown.go
new file mode 100644
index 000000000..0f33692ce
--- /dev/null
+++ b/builder/parallels/common/step_shutdown.go
@@ -0,0 +1,78 @@
+package common
+
+import (
+	"errors"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"time"
+)
+
+// This step shuts down the machine. It first attempts to do so gracefully,
+// but ultimately forcefully shuts it down if that fails.
+//
+// Uses:
+//   communicator packer.Communicator
+//   driver Driver
+//   ui     packer.Ui
+//   vmName string
+//
+// Produces:
+//   <nothing>
+type StepShutdown struct {
+	Command string
+	Timeout time.Duration
+}
+
+func (s *StepShutdown) Run(state multistep.StateBag) multistep.StepAction {
+	comm := state.Get("communicator").(packer.Communicator)
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	if s.Command != "" {
+		ui.Say("Gracefully halting virtual machine...")
+		log.Printf("Executing shutdown command: %s", s.Command)
+		cmd := &packer.RemoteCmd{Command: s.Command}
+		if err := cmd.StartWithUi(comm, ui); err != nil {
+			err := fmt.Errorf("Failed to send shutdown command: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		// Wait for the machine to actually shut down
+		log.Printf("Waiting max %s for shutdown to complete", s.Timeout)
+		shutdownTimer := time.After(s.Timeout)
+		for {
+			running, _ := driver.IsRunning(vmName)
+			if !running {
+				break
+			}
+
+			select {
+			case <-shutdownTimer:
+				err := errors.New("Timeout while waiting for machine to shut down.")
+				state.Put("error", err)
+				ui.Error(err.Error())
+				return multistep.ActionHalt
+			default:
+				time.Sleep(500 * time.Millisecond)
+			}
+		}
+	} else {
+		ui.Say("Halting the virtual machine...")
+		if err := driver.Stop(vmName); err != nil {
+			err := fmt.Errorf("Error stopping VM: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	}
+
+	log.Println("VM shut down.")
+	return multistep.ActionContinue
+}
+
+func (s *StepShutdown) Cleanup(state multistep.StateBag) {}
diff --git a/builder/parallels/common/step_shutdown_test.go b/builder/parallels/common/step_shutdown_test.go
new file mode 100644
index 000000000..215eefd30
--- /dev/null
+++ b/builder/parallels/common/step_shutdown_test.go
@@ -0,0 +1,105 @@
+package common
+
+import (
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"testing"
+	"time"
+)
+
+func TestStepShutdown_impl(t *testing.T) {
+	var _ multistep.Step = new(StepShutdown)
+}
+
+func TestStepShutdown_noShutdownCommand(t *testing.T) {
+	state := testState(t)
+	step := new(StepShutdown)
+
+	comm := new(packer.MockCommunicator)
+	state.Put("communicator", comm)
+	state.Put("vmName", "foo")
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test that Stop was just called
+	if driver.StopName != "foo" {
+		t.Fatal("should call stop")
+	}
+	if comm.StartCalled {
+		t.Fatal("comm start should not be called")
+	}
+}
+
+func TestStepShutdown_shutdownCommand(t *testing.T) {
+	state := testState(t)
+	step := new(StepShutdown)
+	step.Command = "poweroff"
+	step.Timeout = 1 * time.Second
+
+	comm := new(packer.MockCommunicator)
+	state.Put("communicator", comm)
+	state.Put("vmName", "foo")
+
+	driver := state.Get("driver").(*DriverMock)
+	driver.IsRunningReturn = true
+
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		driver.Lock()
+		defer driver.Unlock()
+		driver.IsRunningReturn = false
+	}()
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test that Stop was just called
+	if driver.StopName != "" {
+		t.Fatal("should not call stop")
+	}
+	if comm.StartCmd.Command != step.Command {
+		t.Fatal("comm start should be called")
+	}
+}
+
+func TestStepShutdown_shutdownTimeout(t *testing.T) {
+	state := testState(t)
+	step := new(StepShutdown)
+	step.Command = "poweroff"
+	step.Timeout = 1 * time.Second
+
+	comm := new(packer.MockCommunicator)
+	state.Put("communicator", comm)
+	state.Put("vmName", "foo")
+
+	driver := state.Get("driver").(*DriverMock)
+	driver.IsRunningReturn = true
+
+	go func() {
+		time.Sleep(2 * time.Second)
+		driver.Lock()
+		defer driver.Unlock()
+		driver.IsRunningReturn = false
+	}()
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionHalt {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); !ok {
+		t.Fatal("should have error")
+	}
+}
diff --git a/builder/parallels/common/step_test.go b/builder/parallels/common/step_test.go
new file mode 100644
index 000000000..9bf6d5d67
--- /dev/null
+++ b/builder/parallels/common/step_test.go
@@ -0,0 +1,18 @@
+package common
+
+import (
+	"bytes"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func testState(t *testing.T) multistep.StateBag {
+	state := new(multistep.BasicStateBag)
+	state.Put("driver", new(DriverMock))
+	state.Put("ui", &packer.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	})
+	return state
+}
diff --git a/builder/parallels/common/step_type_boot_command.go b/builder/parallels/common/step_type_boot_command.go
new file mode 100644
index 000000000..dbc224d18
--- /dev/null
+++ b/builder/parallels/common/step_type_boot_command.go
@@ -0,0 +1,257 @@
+package common
+
+import (
+	"fmt"
+	"log"
+	"strings"
+	"time"
+	"unicode"
+	"unicode/utf8"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+const KeyLeftShift uint32 = 0xFFE1
+
+type bootCommandTemplateData struct {
+	HTTPIP   string
+	HTTPPort uint
+	Name     string
+}
+
+// This step "types" the boot command into the VM via the prltype script, built on the
+// Parallels Virtualization SDK - Python API.
+//
+// Uses:
+//   driver Driver
+//   http_port int
+//   ui     packer.Ui
+//   vmName string
+//
+// Produces:
+//   <nothing>
+type StepTypeBootCommand struct {
+	BootCommand    []string
+	HostInterfaces []string
+	VMName         string
+	Tpl            *packer.ConfigTemplate
+}
+
+func (s *StepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction {
+	httpPort := state.Get("http_port").(uint)
+	ui := state.Get("ui").(packer.Ui)
+	driver := state.Get("driver").(Driver)
+
+	hostIp := "0.0.0.0"
+
+	if len(s.HostInterfaces) > 0 {
+		// Determine the host IP
+		ipFinder := &IfconfigIPFinder{Devices: s.HostInterfaces}
+
+		ip, err := ipFinder.HostIP()
+		if err != nil {
+			err := fmt.Errorf("Error detecting host IP: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+		hostIp = ip
+	}
+
+	ui.Say(fmt.Sprintf("Host IP for the Parallels machine: %s", hostIp))
+
+	tplData := &bootCommandTemplateData{
+		hostIp,
+		httpPort,
+		s.VMName,
+	}
+
+	ui.Say("Typing the boot command...")
+	for _, command := range s.BootCommand {
+		command, err := s.Tpl.Process(command, tplData)
+		if err != nil {
+			err := fmt.Errorf("Error preparing boot command: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		codes := []string{}
+		for _, code := range scancodes(command) {
+			if code == "wait" {
+				if err := driver.SendKeyScanCodes(s.VMName, codes...); err != nil {
+					err := fmt.Errorf("Error sending boot command: %s", err)
+					state.Put("error", err)
+					ui.Error(err.Error())
+					return multistep.ActionHalt
+				}
+				codes = []string{}
+				time.Sleep(1 * time.Second)
+				continue
+			}
+
+			if code == "wait5" {
+				if err := driver.SendKeyScanCodes(s.VMName, codes...); err != nil {
+					err := fmt.Errorf("Error sending boot command: %s", err)
+					state.Put("error", err)
+					ui.Error(err.Error())
+					return multistep.ActionHalt
+				}
+				codes = []string{}
+				time.Sleep(5 * time.Second)
+				continue
+			}
+
+			if code == "wait10" {
+				if err := driver.SendKeyScanCodes(s.VMName, codes...); err != nil {
+					err := fmt.Errorf("Error sending boot command: %s", err)
+					state.Put("error", err)
+					ui.Error(err.Error())
+					return multistep.ActionHalt
+				}
+				codes = []string{}
+				time.Sleep(10 * time.Second)
+				continue
+			}
+
+			// Since typing is sometimes so slow, we check for an interrupt
+			// in between each character.
+			if _, ok := state.GetOk(multistep.StateCancelled); ok {
+				return multistep.ActionHalt
+			}
+			codes = append(codes, code)
+		}
+		log.Printf("Sending scancodes: %#v", codes)
+		if err := driver.SendKeyScanCodes(s.VMName, codes...); err != nil {
+			err := fmt.Errorf("Error sending boot command: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+	}
+
+	return multistep.ActionContinue
+}
+
+func (*StepTypeBootCommand) Cleanup(multistep.StateBag) {}
+
+func scancodes(message string) []string {
+	// Scancodes reference: http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
+	//
+	// Scancodes represent raw keyboard output and are fed to the VM by the
+	// Parallels Virtualization SDK - C API, PrlDevKeyboard_SendKeyEvent
+	//
+	// Scancodes are recorded here in pairs. The first entry represents
+	// the key press and the second entry represents the key release and is
+	// derived from the first by the addition of 0x80.
+	special := make(map[string][]string)
+	special["<bs>"] = []string{"0e", "8e"}
+	special["<del>"] = []string{"53", "d3"}
+	special["<enter>"] = []string{"1c", "9c"}
+	special["<esc>"] = []string{"01", "81"}
+	special["<f1>"] = []string{"3b", "bb"}
+	special["<f2>"] = []string{"3c", "bc"}
+	special["<f3>"] = []string{"3d", "bd"}
+	special["<f4>"] = []string{"3e", "be"}
+	special["<f5>"] = []string{"3f", "bf"}
+	special["<f6>"] = []string{"40", "c0"}
+	special["<f7>"] = []string{"41", "c1"}
+	special["<f8>"] = []string{"42", "c2"}
+	special["<f9>"] = []string{"43", "c3"}
+	special["<f10>"] = []string{"44", "c4"}
+	special["<return>"] = []string{"1c", "9c"}
+	special["<tab>"] = []string{"0f", "8f"}
+
+	special["<up>"] = []string{"48", "c8"}
+	special["<down>"] = []string{"50", "d0"}
+	special["<left>"] = []string{"4b", "cb"}
+	special["<right>"] = []string{"4d", "cd"}
+	special["<spacebar>"] = []string{"39", "b9"}
+	special["<insert>"] = []string{"52", "d2"}
+	special["<home>"] = []string{"47", "c7"}
+	special["<end>"] = []string{"4f", "cf"}
+	special["<pageUp>"] = []string{"49", "c9"}
+	special["<pageDown>"] = []string{"51", "d1"}
+
+	shiftedChars := "!@#$%^&*()_+{}:\"~|<>?"
+
+	scancodeIndex := make(map[string]uint)
+	scancodeIndex["1234567890-="] = 0x02
+	scancodeIndex["!@#$%^&*()_+"] = 0x02
+	scancodeIndex["qwertyuiop[]"] = 0x10
+	scancodeIndex["QWERTYUIOP{}"] = 0x10
+	scancodeIndex["asdfghjkl;'`"] = 0x1e
+	scancodeIndex[`ASDFGHJKL:"~`] = 0x1e
+	scancodeIndex["\\zxcvbnm,./"] = 0x2b
+	scancodeIndex["|ZXCVBNM<>?"] = 0x2b
+	scancodeIndex[" "] = 0x39
+
+	scancodeMap := make(map[rune]uint)
+	for chars, start := range scancodeIndex {
+		var i uint = 0
+		for len(chars) > 0 {
+			r, size := utf8.DecodeRuneInString(chars)
+			chars = chars[size:]
+			scancodeMap[r] = start + i
+			i += 1
+		}
+	}
+
+	result := make([]string, 0, len(message)*2)
+	for len(message) > 0 {
+		var scancode []string
+
+		if strings.HasPrefix(message, "<wait>") {
+			log.Printf("Special code <wait> found, will sleep 1 second at this point.")
+			scancode = []string{"wait"}
+			message = message[len("<wait>"):]
+		}
+
+		if strings.HasPrefix(message, "<wait5>") {
+			log.Printf("Special code <wait5> found, will sleep 5 seconds at this point.")
+			scancode = []string{"wait5"}
+			message = message[len("<wait5>"):]
+		}
+
+		if strings.HasPrefix(message, "<wait10>") {
+			log.Printf("Special code <wait10> found, will sleep 10 seconds at this point.")
+			scancode = []string{"wait10"}
+			message = message[len("<wait10>"):]
+		}
+
+		if scancode == nil {
+			for specialCode, specialValue := range special {
+				if strings.HasPrefix(message, specialCode) {
+					log.Printf("Special code '%s' found, replacing with: %s", specialCode, specialValue)
+					scancode = specialValue
+					message = message[len(specialCode):]
+					break
+				}
+			}
+		}
+
+		if scancode == nil {
+			r, size := utf8.DecodeRuneInString(message)
+			message = message[size:]
+			scancodeInt := scancodeMap[r]
+			keyShift := unicode.IsUpper(r) || strings.ContainsRune(shiftedChars, r)
+
+			scancode = make([]string, 0, 4)
+			if keyShift {
+				scancode = append(scancode, "2a")
+			}
+
+			scancode = append(scancode, fmt.Sprintf("%02x", scancodeInt))
+			scancode = append(scancode, fmt.Sprintf("%02x", scancodeInt+0x80))
+
+			if keyShift {
+				scancode = append(scancode, "aa")
+			}
+		}
+
+		result = append(result, scancode...)
+	}
+
+	return result
+}
diff --git a/builder/parallels/common/step_type_boot_command_test.go b/builder/parallels/common/step_type_boot_command_test.go
new file mode 100644
index 000000000..6dbbe9e1c
--- /dev/null
+++ b/builder/parallels/common/step_type_boot_command_test.go
@@ -0,0 +1,77 @@
+package common
+
+import (
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"strings"
+	"testing"
+)
+
+func TestStepTypeBootCommand(t *testing.T) {
+	state := testState(t)
+	tpl, _ := packer.NewConfigTemplate()
+
+	var bootcommand = []string{
+		"1234567890-=<enter><wait>",
+		"!@#$%^&*()_+<enter>",
+		"qwertyuiop[]<enter>",
+		"QWERTYUIOP{}<enter>",
+		"asdfghjkl;'`<enter>",
+		`ASDFGHJKL:"~<enter>`,
+		"\\zxcvbnm,./<enter>",
+		"|ZXCVBNM<>?<enter>",
+		" <enter>",
+	}
+
+	step := StepTypeBootCommand{
+		BootCommand:    bootcommand,
+		HostInterfaces: []string{},
+		VMName:         "myVM",
+		Tpl:            tpl,
+	}
+
+	comm := new(packer.MockCommunicator)
+	state.Put("communicator", comm)
+
+	driver := state.Get("driver").(*DriverMock)
+	driver.VersionResult = "foo"
+	state.Put("http_port", uint(0))
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Verify
+	var expected = [][]string{
+		[]string{"02", "82", "03", "83", "04", "84", "05", "85", "06", "86", "07", "87", "08", "88", "09", "89", "0a", "8a", "0b", "8b", "0c", "8c", "0d", "8d", "1c", "9c"},
+		[]string{},
+		[]string{"2a", "02", "82", "aa", "2a", "03", "83", "aa", "2a", "04", "84", "aa", "2a", "05", "85", "aa", "2a", "06", "86", "aa", "2a", "07", "87", "aa", "2a", "08", "88", "aa", "2a", "09", "89", "aa", "2a", "0a", "8a", "aa", "2a", "0b", "8b", "aa", "2a", "0c", "8c", "aa", "2a", "0d", "8d", "aa", "1c", "9c"},
+		[]string{"10", "90", "11", "91", "12", "92", "13", "93", "14", "94", "15", "95", "16", "96", "17", "97", "18", "98", "19", "99", "1a", "9a", "1b", "9b", "1c", "9c"},
+		[]string{"2a", "10", "90", "aa", "2a", "11", "91", "aa", "2a", "12", "92", "aa", "2a", "13", "93", "aa", "2a", "14", "94", "aa", "2a", "15", "95", "aa", "2a", "16", "96", "aa", "2a", "17", "97", "aa", "2a", "18", "98", "aa", "2a", "19", "99", "aa", "2a", "1a", "9a", "aa", "2a", "1b", "9b", "aa", "1c", "9c"},
+		[]string{"1e", "9e", "1f", "9f", "20", "a0", "21", "a1", "22", "a2", "23", "a3", "24", "a4", "25", "a5", "26", "a6", "27", "a7", "28", "a8", "29", "a9", "1c", "9c"},
+		[]string{"2a", "1e", "9e", "aa", "2a", "1f", "9f", "aa", "2a", "20", "a0", "aa", "2a", "21", "a1", "aa", "2a", "22", "a2", "aa", "2a", "23", "a3", "aa", "2a", "24", "a4", "aa", "2a", "25", "a5", "aa", "2a", "26", "a6", "aa", "2a", "27", "a7", "aa", "2a", "28", "a8", "aa", "2a", "29", "a9", "aa", "1c", "9c"},
+		[]string{"2b", "ab", "2c", "ac", "2d", "ad", "2e", "ae", "2f", "af", "30", "b0", "31", "b1", "32", "b2", "33", "b3", "34", "b4", "35", "b5", "1c", "9c"},
+		[]string{"2a", "2b", "ab", "aa", "2a", "2c", "ac", "aa", "2a", "2d", "ad", "aa", "2a", "2e", "ae", "aa", "2a", "2f", "af", "aa", "2a", "30", "b0", "aa", "2a", "31", "b1", "aa", "2a", "32", "b2", "aa", "2a", "33", "b3", "aa", "2a", "34", "b4", "aa", "2a", "35", "b5", "aa", "1c", "9c"},
+		[]string{"39", "b9", "1c", "9c"},
+	}
+	fail := false
+
+	for i := range driver.SendKeyScanCodesCalls {
+		t.Logf("prltype %s\n", strings.Join(driver.SendKeyScanCodesCalls[i], " "))
+	}
+
+	for i := range expected {
+		for j := range expected[i] {
+			if driver.SendKeyScanCodesCalls[i][j] != expected[i][j] {
+				fail = true
+			}
+		}
+	}
+	if fail {
+		t.Fatalf("Sent bad scancodes: %#v\n Expected: %#v", driver.SendKeyScanCodesCalls, expected)
+	}
+}
diff --git a/builder/parallels/common/step_upload_parallels_tools.go b/builder/parallels/common/step_upload_parallels_tools.go
new file mode 100644
index 000000000..ae511a1e8
--- /dev/null
+++ b/builder/parallels/common/step_upload_parallels_tools.go
@@ -0,0 +1,75 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"os"
+)
+
+// This step uploads the Parallels Tools ISO to the virtual machine.
+//
+// Uses:
+//   communicator packer.Communicator
+//   parallels_tools_path string
+//   ui packer.Ui
+//
+// Produces:
+type toolsPathTemplate struct {
+	Flavor string
+}
+
+// This step uploads the guest additions ISO to the VM.
+type StepUploadParallelsTools struct {
+	ParallelsToolsFlavor    string
+	ParallelsToolsGuestPath string
+	ParallelsToolsMode      string
+	Tpl                     *packer.ConfigTemplate
+}
+
+func (s *StepUploadParallelsTools) Run(state multistep.StateBag) multistep.StepAction {
+	comm := state.Get("communicator").(packer.Communicator)
+	ui := state.Get("ui").(packer.Ui)
+
+	// If we're attaching then don't do this, since we attached.
+	if s.ParallelsToolsMode != ParallelsToolsModeUpload {
+		log.Println("Not uploading Parallels Tools since mode is not upload")
+		return multistep.ActionContinue
+	}
+
+	// Get the Paralells Tools path on the host machine
+	parallelsToolsPath := state.Get("parallels_tools_path").(string)
+
+	f, err := os.Open(parallelsToolsPath)
+	if err != nil {
+		state.Put("error", fmt.Errorf("Error opening Parallels Tools ISO: %s", err))
+		return multistep.ActionHalt
+	}
+	defer f.Close()
+
+	tplData := &toolsPathTemplate{
+		Flavor: s.ParallelsToolsFlavor,
+	}
+
+	s.ParallelsToolsGuestPath, err = s.Tpl.Process(s.ParallelsToolsGuestPath, tplData)
+	if err != nil {
+		err := fmt.Errorf("Error preparing Parallels Tools path: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	ui.Say(fmt.Sprintf("Uploading Parallels Tools for '%s' to path: '%s'",
+		s.ParallelsToolsFlavor, s.ParallelsToolsGuestPath))
+	if err := comm.Upload(s.ParallelsToolsGuestPath, f, nil); err != nil {
+		err := fmt.Errorf("Error uploading Parallels Tools: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepUploadParallelsTools) Cleanup(state multistep.StateBag) {}
diff --git a/builder/parallels/common/step_upload_version.go b/builder/parallels/common/step_upload_version.go
new file mode 100644
index 000000000..8bf5aa7dc
--- /dev/null
+++ b/builder/parallels/common/step_upload_version.go
@@ -0,0 +1,44 @@
+package common
+
+import (
+	"bytes"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+// This step uploads a file containing the Parallels version, which
+// can be useful for various provisioning reasons.
+type StepUploadVersion struct {
+	Path string
+}
+
+func (s *StepUploadVersion) Run(state multistep.StateBag) multistep.StepAction {
+	comm := state.Get("communicator").(packer.Communicator)
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+
+	if s.Path == "" {
+		log.Println("ParallelsVersionFile is empty. Not uploading.")
+		return multistep.ActionContinue
+	}
+
+	version, err := driver.Version()
+	if err != nil {
+		state.Put("error", fmt.Errorf("Error reading version for metadata upload: %s", err))
+		return multistep.ActionHalt
+	}
+
+	ui.Say(fmt.Sprintf("Uploading Parallels version info (%s)", version))
+	var data bytes.Buffer
+	data.WriteString(version)
+	if err := comm.Upload(s.Path, &data, nil); err != nil {
+		state.Put("error", fmt.Errorf("Error uploading Parallels version: %s", err))
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *StepUploadVersion) Cleanup(state multistep.StateBag) {}
diff --git a/builder/parallels/common/step_upload_version_test.go b/builder/parallels/common/step_upload_version_test.go
new file mode 100644
index 000000000..234c4b5df
--- /dev/null
+++ b/builder/parallels/common/step_upload_version_test.go
@@ -0,0 +1,61 @@
+package common
+
+import (
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func TestStepUploadVersion_impl(t *testing.T) {
+	var _ multistep.Step = new(StepUploadVersion)
+}
+
+func TestStepUploadVersion(t *testing.T) {
+	state := testState(t)
+	step := new(StepUploadVersion)
+	step.Path = "foopath"
+
+	comm := new(packer.MockCommunicator)
+	state.Put("communicator", comm)
+
+	driver := state.Get("driver").(*DriverMock)
+	driver.VersionResult = "foo"
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Verify
+	if comm.UploadPath != "foopath" {
+		t.Fatalf("bad: %#v", comm.UploadPath)
+	}
+	if comm.UploadData != "foo" {
+		t.Fatalf("upload data bad: %#v", comm.UploadData)
+	}
+}
+
+func TestStepUploadVersion_noPath(t *testing.T) {
+	state := testState(t)
+	step := new(StepUploadVersion)
+	step.Path = ""
+
+	comm := new(packer.MockCommunicator)
+	state.Put("communicator", comm)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Verify
+	if comm.UploadCalled {
+		t.Fatal("bad")
+	}
+}
diff --git a/builder/parallels/common/tools_config.go b/builder/parallels/common/tools_config.go
new file mode 100644
index 000000000..19993fb77
--- /dev/null
+++ b/builder/parallels/common/tools_config.go
@@ -0,0 +1,78 @@
+package common
+
+import (
+	"errors"
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+	"text/template"
+)
+
+// These are the different valid mode values for "parallels_tools_mode" which
+// determine how guest additions are delivered to the guest.
+const (
+	ParallelsToolsModeDisable string = "disable"
+	ParallelsToolsModeAttach         = "attach"
+	ParallelsToolsModeUpload         = "upload"
+)
+
+type ToolsConfig struct {
+	ParallelsToolsFlavor    string `mapstructure:"parallels_tools_flavor"`
+	ParallelsToolsGuestPath string `mapstructure:"parallels_tools_guest_path"`
+	ParallelsToolsMode      string `mapstructure:"parallels_tools_mode"`
+}
+
+func (c *ToolsConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.ParallelsToolsMode == "" {
+		c.ParallelsToolsMode = ParallelsToolsModeUpload
+	}
+
+	if c.ParallelsToolsGuestPath == "" {
+		c.ParallelsToolsGuestPath = "prl-tools-{{.Flavor}}.iso"
+	}
+
+	templates := map[string]*string{
+		"parallels_tools_flavor": &c.ParallelsToolsFlavor,
+		"parallels_tools_mode":   &c.ParallelsToolsMode,
+	}
+
+	var err error
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	if _, err := template.New("path").Parse(c.ParallelsToolsGuestPath); err != nil {
+		errs = append(errs, fmt.Errorf("parallels_tools_guest_path invalid: %s", err))
+	}
+
+	validMode := false
+	validModes := []string{
+		ParallelsToolsModeDisable,
+		ParallelsToolsModeAttach,
+		ParallelsToolsModeUpload,
+	}
+
+	for _, mode := range validModes {
+		if c.ParallelsToolsMode == mode {
+			validMode = true
+			break
+		}
+	}
+
+	if !validMode {
+		errs = append(errs,
+			fmt.Errorf("parallels_tools_mode is invalid. Must be one of: %v",
+				validModes))
+	}
+
+	if c.ParallelsToolsFlavor == "" {
+		if c.ParallelsToolsMode != ParallelsToolsModeDisable {
+			errs = append(errs, errors.New("parallels_tools_flavor must be specified."))
+		}
+	}
+
+	return errs
+}
diff --git a/builder/parallels/common/tools_config_test.go b/builder/parallels/common/tools_config_test.go
new file mode 100644
index 000000000..5f5a8a35d
--- /dev/null
+++ b/builder/parallels/common/tools_config_test.go
@@ -0,0 +1,123 @@
+package common
+
+import (
+	"testing"
+)
+
+func testToolsConfig() *ToolsConfig {
+	return &ToolsConfig{
+		ParallelsToolsFlavor:    "foo",
+		ParallelsToolsGuestPath: "foo",
+		ParallelsToolsMode:      "attach",
+	}
+}
+
+func TestToolsConfigPrepare(t *testing.T) {
+	c := testToolsConfig()
+	errs := c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("bad err: %#v", errs)
+	}
+}
+
+func TestToolsConfigPrepare_ParallelsToolsMode(t *testing.T) {
+	var c *ToolsConfig
+	var errs []error
+
+	// Test default mode
+	c = testToolsConfig()
+	c.ParallelsToolsMode = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+	if c.ParallelsToolsMode != ParallelsToolsModeUpload {
+		t.Errorf("bad parallels tools mode: %s", c.ParallelsToolsMode)
+	}
+
+	// Test another mode
+	c = testToolsConfig()
+	c.ParallelsToolsMode = "attach"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+	if c.ParallelsToolsMode != ParallelsToolsModeAttach {
+		t.Fatalf("bad mode: %s", c.ParallelsToolsMode)
+	}
+
+	// Test invalid mode
+	c = testToolsConfig()
+	c.ParallelsToolsMode = "invalid_mode"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+}
+
+func TestToolsConfigPrepare_ParallelsToolsGuestPath(t *testing.T) {
+	var c *ToolsConfig
+	var errs []error
+
+	// Test default path
+	c = testToolsConfig()
+	c.ParallelsToolsGuestPath = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %#v", errs)
+	}
+	if c.ParallelsToolsGuestPath == "" {
+		t.Fatal("should not be empty")
+	}
+
+	// Test with a bad value
+	c = testToolsConfig()
+	c.ParallelsToolsGuestPath = "{{{nope}"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+
+	// Test with a good one
+	c = testToolsConfig()
+	c.ParallelsToolsGuestPath = "foo"
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %s", errs)
+	}
+
+	if c.ParallelsToolsGuestPath != "foo" {
+		t.Fatalf("bad guest path: %s", c.ParallelsToolsGuestPath)
+	}
+}
+
+func TestToolsConfigPrepare_ParallelsToolsFlavor(t *testing.T) {
+	var c *ToolsConfig
+	var errs []error
+
+	// Test with a default value
+	c = testToolsConfig()
+	c.ParallelsToolsFlavor = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+
+	// Test with an bad value
+	c = testToolsConfig()
+	c.ParallelsToolsMode = "attach"
+	c.ParallelsToolsFlavor = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) == 0 {
+		t.Fatal("should have error")
+	}
+
+	// Test with a good one
+	c = testToolsConfig()
+	c.ParallelsToolsMode = "disable"
+	c.ParallelsToolsFlavor = ""
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("should not have error: %s", errs)
+	}
+}
diff --git a/builder/parallels/iso/builder.go b/builder/parallels/iso/builder.go
new file mode 100644
index 000000000..5b4c628a1
--- /dev/null
+++ b/builder/parallels/iso/builder.go
@@ -0,0 +1,341 @@
+package iso
+
+import (
+	"errors"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"strings"
+)
+
+const BuilderId = "rickard-von-essen.parallels"
+
+type Builder struct {
+	config config
+	runner multistep.Runner
+}
+
+type config struct {
+	common.PackerConfig                 `mapstructure:",squash"`
+	parallelscommon.FloppyConfig        `mapstructure:",squash"`
+	parallelscommon.OutputConfig        `mapstructure:",squash"`
+	parallelscommon.PrlctlConfig        `mapstructure:",squash"`
+	parallelscommon.PrlctlVersionConfig `mapstructure:",squash"`
+	parallelscommon.RunConfig           `mapstructure:",squash"`
+	parallelscommon.ShutdownConfig      `mapstructure:",squash"`
+	parallelscommon.SSHConfig           `mapstructure:",squash"`
+	parallelscommon.ToolsConfig         `mapstructure:",squash"`
+
+	BootCommand        []string `mapstructure:"boot_command"`
+	DiskSize           uint     `mapstructure:"disk_size"`
+	GuestOSType        string   `mapstructure:"guest_os_type"`
+	HardDriveInterface string   `mapstructure:"hard_drive_interface"`
+	HostInterfaces     []string `mapstructure:"host_interfaces"`
+	HTTPDir            string   `mapstructure:"http_directory"`
+	HTTPPortMin        uint     `mapstructure:"http_port_min"`
+	HTTPPortMax        uint     `mapstructure:"http_port_max"`
+	ISOChecksum        string   `mapstructure:"iso_checksum"`
+	ISOChecksumType    string   `mapstructure:"iso_checksum_type"`
+	ISOUrls            []string `mapstructure:"iso_urls"`
+	VMName             string   `mapstructure:"vm_name"`
+
+	RawSingleISOUrl string `mapstructure:"iso_url"`
+
+	// Deprecated parameters
+	GuestOSDistribution    string `mapstructure:"guest_os_distribution"`
+	ParallelsToolsHostPath string `mapstructure:"parallels_tools_host_path"`
+
+	tpl *packer.ConfigTemplate
+}
+
+func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+
+	md, err := common.DecodeConfig(&b.config, raws...)
+	if err != nil {
+		return nil, err
+	}
+
+	b.config.tpl, err = packer.NewConfigTemplate()
+	if err != nil {
+		return nil, err
+	}
+	b.config.tpl.UserVars = b.config.PackerUserVars
+
+	// Accumulate any errors and warnings
+	errs := common.CheckUnusedConfig(md)
+	errs = packer.MultiErrorAppend(errs, b.config.FloppyConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(
+		errs, b.config.OutputConfig.Prepare(b.config.tpl, &b.config.PackerConfig)...)
+	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.PrlctlConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.PrlctlVersionConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.SSHConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.ToolsConfig.Prepare(b.config.tpl)...)
+	warnings := make([]string, 0)
+
+	if b.config.DiskSize == 0 {
+		b.config.DiskSize = 40000
+	}
+
+	if b.config.HardDriveInterface == "" {
+		b.config.HardDriveInterface = "sata"
+	}
+
+	if b.config.GuestOSType == "" {
+		b.config.GuestOSType = "other"
+	}
+
+	if b.config.GuestOSDistribution != "" {
+		// Compatibility with older templates:
+		// Use value of 'guest_os_distribution' if it is defined.
+		b.config.GuestOSType = b.config.GuestOSDistribution
+		warnings = append(warnings,
+			"A 'guest_os_distribution' has been completely replaced with 'guest_os_type'\n"+
+				"It is recommended to remove it and assign the previous value to 'guest_os_type'.\n"+
+				"Run it to see all available values: `prlctl create x -d list` ")
+	}
+
+	if b.config.HTTPPortMin == 0 {
+		b.config.HTTPPortMin = 8000
+	}
+
+	if b.config.HTTPPortMax == 0 {
+		b.config.HTTPPortMax = 9000
+	}
+
+	if len(b.config.HostInterfaces) == 0 {
+		b.config.HostInterfaces = []string{"en0", "en1", "en2", "en3", "en4", "en5", "en6", "en7",
+			"en8", "en9", "ppp0", "ppp1", "ppp2"}
+	}
+
+	if b.config.VMName == "" {
+		b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName)
+	}
+
+	// Errors
+	templates := map[string]*string{
+		"guest_os_type":        &b.config.GuestOSType,
+		"hard_drive_interface": &b.config.HardDriveInterface,
+		"http_directory":       &b.config.HTTPDir,
+		"iso_checksum":         &b.config.ISOChecksum,
+		"iso_checksum_type":    &b.config.ISOChecksumType,
+		"iso_url":              &b.config.RawSingleISOUrl,
+		"vm_name":              &b.config.VMName,
+	}
+
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = b.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	for i, url := range b.config.ISOUrls {
+		var err error
+		b.config.ISOUrls[i], err = b.config.tpl.Process(url, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing iso_urls[%d]: %s", i, err))
+		}
+	}
+
+	for i, command := range b.config.BootCommand {
+		if err := b.config.tpl.Validate(command); err != nil {
+			errs = packer.MultiErrorAppend(errs,
+				fmt.Errorf("Error processing boot_command[%d]: %s", i, err))
+		}
+	}
+
+	if b.config.HardDriveInterface != "ide" && b.config.HardDriveInterface != "sata" && b.config.HardDriveInterface != "scsi" {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("hard_drive_interface can only be ide, sata, or scsi"))
+	}
+
+	if b.config.HTTPPortMin > b.config.HTTPPortMax {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("http_port_min must be less than http_port_max"))
+	}
+
+	if b.config.ISOChecksumType == "" {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("The iso_checksum_type must be specified."))
+	} else {
+		b.config.ISOChecksumType = strings.ToLower(b.config.ISOChecksumType)
+		if b.config.ISOChecksumType != "none" {
+			if b.config.ISOChecksum == "" {
+				errs = packer.MultiErrorAppend(
+					errs, errors.New("Due to large file sizes, an iso_checksum is required"))
+			} else {
+				b.config.ISOChecksum = strings.ToLower(b.config.ISOChecksum)
+			}
+
+			if h := common.HashForType(b.config.ISOChecksumType); h == nil {
+				errs = packer.MultiErrorAppend(
+					errs,
+					fmt.Errorf("Unsupported checksum type: %s", b.config.ISOChecksumType))
+			}
+		}
+	}
+
+	if b.config.RawSingleISOUrl == "" && len(b.config.ISOUrls) == 0 {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("One of iso_url or iso_urls must be specified."))
+	} else if b.config.RawSingleISOUrl != "" && len(b.config.ISOUrls) > 0 {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("Only one of iso_url or iso_urls may be specified."))
+	} else if b.config.RawSingleISOUrl != "" {
+		b.config.ISOUrls = []string{b.config.RawSingleISOUrl}
+	}
+
+	for i, url := range b.config.ISOUrls {
+		b.config.ISOUrls[i], err = common.DownloadableURL(url)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Failed to parse iso_url %d: %s", i+1, err))
+		}
+	}
+
+	// Warnings
+	if b.config.ISOChecksumType == "none" {
+		warnings = append(warnings,
+			"A checksum type of 'none' was specified. Since ISO files are so big,\n"+
+				"a checksum is highly recommended.")
+	}
+
+	if b.config.ShutdownCommand == "" {
+		warnings = append(warnings,
+			"A shutdown_command was not specified. Without a shutdown command, Packer\n"+
+				"will forcibly halt the virtual machine, which may result in data loss.")
+	}
+
+	if b.config.ParallelsToolsHostPath != "" {
+		warnings = append(warnings,
+			"A 'parallels_tools_host_path' has been deprecated and not in use anymore\n"+
+				"You can remove it from your Packer template.")
+	}
+
+	if errs != nil && len(errs.Errors) > 0 {
+		return warnings, errs
+	}
+
+	return warnings, nil
+}
+
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	// Create the driver that we'll use to communicate with Parallels
+	driver, err := parallelscommon.NewDriver()
+	if err != nil {
+		return nil, fmt.Errorf("Failed creating Parallels driver: %s", err)
+	}
+
+	steps := []multistep.Step{
+		&parallelscommon.StepPrepareParallelsTools{
+			ParallelsToolsFlavor: b.config.ParallelsToolsFlavor,
+			ParallelsToolsMode:   b.config.ParallelsToolsMode,
+		},
+		&common.StepDownload{
+			Checksum:     b.config.ISOChecksum,
+			ChecksumType: b.config.ISOChecksumType,
+			Description:  "ISO",
+			ResultKey:    "iso_path",
+			Url:          b.config.ISOUrls,
+		},
+		&parallelscommon.StepOutputDir{
+			Force: b.config.PackerForce,
+			Path:  b.config.OutputDir,
+		},
+		&common.StepCreateFloppy{
+			Files: b.config.FloppyFiles,
+		},
+		new(stepHTTPServer),
+		new(stepCreateVM),
+		new(stepCreateDisk),
+		new(stepAttachISO),
+		&parallelscommon.StepAttachParallelsTools{
+			ParallelsToolsMode: b.config.ParallelsToolsMode,
+		},
+		new(parallelscommon.StepAttachFloppy),
+		&parallelscommon.StepPrlctl{
+			Commands: b.config.Prlctl,
+			Tpl:      b.config.tpl,
+		},
+		&parallelscommon.StepRun{
+			BootWait: b.config.BootWait,
+			Headless: b.config.Headless, // TODO: migth work on Enterprise Ed.
+		},
+		&parallelscommon.StepTypeBootCommand{
+			BootCommand:    b.config.BootCommand,
+			HostInterfaces: b.config.HostInterfaces,
+			VMName:         b.config.VMName,
+			Tpl:            b.config.tpl,
+		},
+		&common.StepConnectSSH{
+			SSHAddress:     parallelscommon.SSHAddress,
+			SSHConfig:      parallelscommon.SSHConfigFunc(b.config.SSHConfig),
+			SSHWaitTimeout: b.config.SSHWaitTimeout,
+		},
+		&parallelscommon.StepUploadVersion{
+			Path: b.config.PrlctlVersionFile,
+		},
+		&parallelscommon.StepUploadParallelsTools{
+			ParallelsToolsFlavor:    b.config.ParallelsToolsFlavor,
+			ParallelsToolsGuestPath: b.config.ParallelsToolsGuestPath,
+			ParallelsToolsMode:      b.config.ParallelsToolsMode,
+			Tpl:                     b.config.tpl,
+		},
+		new(common.StepProvision),
+		&parallelscommon.StepShutdown{
+			Command: b.config.ShutdownCommand,
+			Timeout: b.config.ShutdownTimeout,
+		},
+	}
+
+	// Setup the state bag
+	state := new(multistep.BasicStateBag)
+	state.Put("cache", cache)
+	state.Put("config", &b.config)
+	state.Put("driver", driver)
+	state.Put("hook", hook)
+	state.Put("ui", ui)
+
+	// Run
+	if b.config.PackerDebug {
+		b.runner = &multistep.DebugRunner{
+			Steps:   steps,
+			PauseFn: common.MultistepDebugFn(ui),
+		}
+	} else {
+		b.runner = &multistep.BasicRunner{Steps: steps}
+	}
+
+	b.runner.Run(state)
+
+	// If there was an error, return that
+	if rawErr, ok := state.GetOk("error"); ok {
+		return nil, rawErr.(error)
+	}
+
+	// If we were interrupted or cancelled, then just exit.
+	if _, ok := state.GetOk(multistep.StateCancelled); ok {
+		return nil, errors.New("Build was cancelled.")
+	}
+
+	if _, ok := state.GetOk(multistep.StateHalted); ok {
+		return nil, errors.New("Build was halted.")
+	}
+
+	return parallelscommon.NewArtifact(b.config.OutputDir)
+}
+
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}
diff --git a/builder/parallels/iso/builder_test.go b/builder/parallels/iso/builder_test.go
new file mode 100644
index 000000000..9c7f56f6b
--- /dev/null
+++ b/builder/parallels/iso/builder_test.go
@@ -0,0 +1,366 @@
+package iso
+
+import (
+	"github.com/mitchellh/packer/packer"
+	"reflect"
+	"testing"
+)
+
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"iso_checksum":           "foo",
+		"iso_checksum_type":      "md5",
+		"iso_url":                "http://www.google.com/",
+		"shutdown_command":       "yes",
+		"ssh_username":           "foo",
+		"parallels_tools_flavor": "lin",
+
+		packer.BuildNameConfigKey: "foo",
+	}
+}
+
+func TestBuilder_ImplementsBuilder(t *testing.T) {
+	var raw interface{}
+	raw = &Builder{}
+	if _, ok := raw.(packer.Builder); !ok {
+		t.Error("Builder must implement builder.")
+	}
+}
+
+func TestBuilderPrepare_Defaults(t *testing.T) {
+	var b Builder
+	config := testConfig()
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.GuestOSType != "other" {
+		t.Errorf("bad guest OS type: %s", b.config.GuestOSType)
+	}
+
+	if b.config.VMName != "packer-foo" {
+		t.Errorf("bad vm name: %s", b.config.VMName)
+	}
+}
+
+func TestBuilderPrepare_DiskSize(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	delete(config, "disk_size")
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("bad err: %s", err)
+	}
+
+	if b.config.DiskSize != 40000 {
+		t.Fatalf("bad size: %d", b.config.DiskSize)
+	}
+
+	config["disk_size"] = 60000
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.DiskSize != 60000 {
+		t.Fatalf("bad size: %s", b.config.DiskSize)
+	}
+}
+
+func TestBuilderPrepare_GuestOSType(t *testing.T) {
+	var b Builder
+	config := testConfig()
+	delete(config, "guest_os_distribution")
+
+	// Test deprecated parameter
+	config["guest_os_distribution"] = "bolgenos"
+	warns, err := b.Prepare(config)
+	if len(warns) == 0 {
+		t.Fatalf("should have warning")
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+	if b.config.GuestOSType != "bolgenos" {
+		t.Fatalf("bad: %s", b.config.GuestOSType)
+	}
+}
+
+func TestBuilderPrepare_HardDriveInterface(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test a default boot_wait
+	delete(config, "hard_drive_interface")
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if b.config.HardDriveInterface != "sata" {
+		t.Fatalf("bad: %s", b.config.HardDriveInterface)
+	}
+
+	// Test with a bad
+	config["hard_drive_interface"] = "fake"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test with a good
+	config["hard_drive_interface"] = "scsi"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+}
+
+func TestBuilderPrepare_HTTPPort(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Bad
+	config["http_port_min"] = 1000
+	config["http_port_max"] = 500
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Bad
+	config["http_port_min"] = -500
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Good
+	config["http_port_min"] = 500
+	config["http_port_max"] = 1000
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+}
+
+func TestBuilderPrepare_InvalidKey(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Add a random key
+	config["i_should_not_be_valid"] = true
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+}
+
+func TestBuilderPrepare_ISOChecksum(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test bad
+	config["iso_checksum"] = ""
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test good
+	config["iso_checksum"] = "FOo"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.ISOChecksum != "foo" {
+		t.Fatalf("should've lowercased: %s", b.config.ISOChecksum)
+	}
+}
+
+func TestBuilderPrepare_ISOChecksumType(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test bad
+	config["iso_checksum_type"] = ""
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test good
+	config["iso_checksum_type"] = "mD5"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.ISOChecksumType != "md5" {
+		t.Fatalf("should've lowercased: %s", b.config.ISOChecksumType)
+	}
+
+	// Test unknown
+	config["iso_checksum_type"] = "fake"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test none
+	config["iso_checksum_type"] = "none"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) == 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	if b.config.ISOChecksumType != "none" {
+		t.Fatalf("should've lowercased: %s", b.config.ISOChecksumType)
+	}
+}
+
+func TestBuilderPrepare_ISOUrl(t *testing.T) {
+	var b Builder
+	config := testConfig()
+	delete(config, "iso_url")
+	delete(config, "iso_urls")
+
+	// Test both epty
+	config["iso_url"] = ""
+	b = Builder{}
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test iso_url set
+	config["iso_url"] = "http://www.packer.io"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Errorf("should not have error: %s", err)
+	}
+
+	expected := []string{"http://www.packer.io"}
+	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
+		t.Fatalf("bad: %#v", b.config.ISOUrls)
+	}
+
+	// Test both set
+	config["iso_url"] = "http://www.packer.io"
+	config["iso_urls"] = []string{"http://www.packer.io"}
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test just iso_urls set
+	delete(config, "iso_url")
+	config["iso_urls"] = []string{
+		"http://www.packer.io",
+		"http://www.hashicorp.com",
+	}
+
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Errorf("should not have error: %s", err)
+	}
+
+	expected = []string{
+		"http://www.packer.io",
+		"http://www.hashicorp.com",
+	}
+	if !reflect.DeepEqual(b.config.ISOUrls, expected) {
+		t.Fatalf("bad: %#v", b.config.ISOUrls)
+	}
+}
+
+func TestBuilderPrepare_ParallelsToolsHostPath(t *testing.T) {
+	var b Builder
+	config := testConfig()
+	delete(config, "parallels_tools_host_path")
+
+	// Test that it is deprecated
+	config["parallels_tools_host_path"] = "/path/to/iso"
+	warns, err := b.Prepare(config)
+	if len(warns) == 0 {
+		t.Fatalf("should have warning")
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+}
diff --git a/builder/parallels/iso/step_attach_iso.go b/builder/parallels/iso/step_attach_iso.go
new file mode 100644
index 000000000..428b12fdb
--- /dev/null
+++ b/builder/parallels/iso/step_attach_iso.go
@@ -0,0 +1,105 @@
+package iso
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+// This step attaches the ISO to the virtual machine.
+//
+// Uses:
+//   driver Driver
+//   isoPath string
+//   ui packer.Ui
+//   vmName string
+//
+// Produces:
+type stepAttachISO struct {
+	cdromDevice string
+}
+
+func (s *stepAttachISO) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(parallelscommon.Driver)
+	isoPath := state.Get("iso_path").(string)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	// Attach the disk to the controller
+	ui.Say("Attaching ISO to the new CD/DVD drive...")
+	cdrom, err := driver.DeviceAddCdRom(vmName, isoPath)
+
+	if err != nil {
+		err := fmt.Errorf("Error attaching ISO: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Set new boot order
+	ui.Say("Setting the boot order...")
+	command := []string{
+		"set", vmName,
+		"--device-bootorder", fmt.Sprintf("hdd0 %s cdrom0 net0", cdrom),
+	}
+
+	if err := driver.Prlctl(command...); err != nil {
+		err := fmt.Errorf("Error setting the boot order: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Disable 'cdrom0' device
+	ui.Say("Disabling default CD/DVD drive...")
+	command = []string{
+		"set", vmName,
+		"--device-set", "cdrom0", "--disable",
+	}
+
+	if err := driver.Prlctl(command...); err != nil {
+		err := fmt.Errorf("Error disabling default CD/DVD drive: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	// Track the device name so that we can can delete later
+	s.cdromDevice = cdrom
+
+	return multistep.ActionContinue
+}
+
+func (s *stepAttachISO) Cleanup(state multistep.StateBag) {
+	driver := state.Get("driver").(parallelscommon.Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	// Enable 'cdrom0' device back
+	log.Println("Enabling default CD/DVD drive...")
+	command := []string{
+		"set", vmName,
+		"--device-set", "cdrom0", "--enable", "--disconnect",
+	}
+
+	if err := driver.Prlctl(command...); err != nil {
+		ui.Error(fmt.Sprintf("Error enabling default CD/DVD drive: %s", err))
+	}
+
+	// Detach ISO
+	if s.cdromDevice == "" {
+		return
+	}
+
+	log.Println("Detaching ISO...")
+	command = []string{
+		"set", vmName,
+		"--device-del", s.cdromDevice,
+	}
+
+	if err := driver.Prlctl(command...); err != nil {
+		ui.Error(fmt.Sprintf("Error detaching ISO: %s", err))
+	}
+}
diff --git a/builder/parallels/iso/step_create_disk.go b/builder/parallels/iso/step_create_disk.go
new file mode 100644
index 000000000..8e5fb63d9
--- /dev/null
+++ b/builder/parallels/iso/step_create_disk.go
@@ -0,0 +1,40 @@
+package iso
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/packer"
+	"strconv"
+)
+
+// This step creates the virtual disk that will be used as the
+// hard drive for the virtual machine.
+type stepCreateDisk struct{}
+
+func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*config)
+	driver := state.Get("driver").(parallelscommon.Driver)
+	ui := state.Get("ui").(packer.Ui)
+	vmName := state.Get("vmName").(string)
+
+	command := []string{
+		"set", vmName,
+		"--device-add", "hdd",
+		"--size", strconv.FormatUint(uint64(config.DiskSize), 10),
+		"--iface", config.HardDriveInterface,
+	}
+
+	ui.Say("Creating hard drive...")
+	err := driver.Prlctl(command...)
+	if err != nil {
+		err := fmt.Errorf("Error creating hard drive: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *stepCreateDisk) Cleanup(state multistep.StateBag) {}
diff --git a/builder/parallels/iso/step_create_vm.go b/builder/parallels/iso/step_create_vm.go
new file mode 100644
index 000000000..b48b73dbb
--- /dev/null
+++ b/builder/parallels/iso/step_create_vm.go
@@ -0,0 +1,76 @@
+package iso
+
+import (
+	"fmt"
+
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/packer"
+)
+
+// This step creates the actual virtual machine.
+//
+// Produces:
+//   vmName string - The name of the VM
+type stepCreateVM struct {
+	vmName string
+}
+
+func (s *stepCreateVM) Run(state multistep.StateBag) multistep.StepAction {
+
+	config := state.Get("config").(*config)
+	driver := state.Get("driver").(parallelscommon.Driver)
+	ui := state.Get("ui").(packer.Ui)
+	name := config.VMName
+
+	commands := make([][]string, 8)
+	commands[0] = []string{
+		"create", name,
+		"--distribution", config.GuestOSType,
+		"--dst", config.OutputDir,
+		"--vmtype", "vm",
+		"--no-hdd",
+	}
+	commands[1] = []string{"set", name, "--cpus", "1"}
+	commands[2] = []string{"set", name, "--memsize", "512"}
+	commands[3] = []string{"set", name, "--startup-view", "same"}
+	commands[4] = []string{"set", name, "--on-shutdown", "close"}
+	commands[5] = []string{"set", name, "--on-window-close", "keep-running"}
+	commands[6] = []string{"set", name, "--auto-share-camera", "off"}
+	commands[7] = []string{"set", name, "--smart-guard", "off"}
+
+	ui.Say("Creating virtual machine...")
+	for _, command := range commands {
+		err := driver.Prlctl(command...)
+		ui.Say(fmt.Sprintf("Executing: prlctl %s", command))
+		if err != nil {
+			err := fmt.Errorf("Error creating VM: %s", err)
+			state.Put("error", err)
+			ui.Error(err.Error())
+			return multistep.ActionHalt
+		}
+
+		// Set the VM name property on the first command
+		if s.vmName == "" {
+			s.vmName = name
+		}
+	}
+
+	// Set the final name in the state bag so others can use it
+	state.Put("vmName", s.vmName)
+	return multistep.ActionContinue
+}
+
+func (s *stepCreateVM) Cleanup(state multistep.StateBag) {
+	if s.vmName == "" {
+		return
+	}
+
+	driver := state.Get("driver").(parallelscommon.Driver)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Unregistering virtual machine...")
+	if err := driver.Prlctl("unregister", s.vmName); err != nil {
+		ui.Error(fmt.Sprintf("Error unregistering virtual machine: %s", err))
+	}
+}
diff --git a/builder/vmware/iso/step_http_server.go b/builder/parallels/iso/step_http_server.go
similarity index 90%
rename from builder/vmware/iso/step_http_server.go
rename to builder/parallels/iso/step_http_server.go
index 24da8dd9d..3d86139e3 100644
--- a/builder/vmware/iso/step_http_server.go
+++ b/builder/parallels/iso/step_http_server.go
@@ -10,8 +10,9 @@ import (
 	"net/http"
 )
 
-// This step creates and runs the HTTP server that is serving the files
-// specified by the 'http_files` configuration parameter in the template.
+// This step creates and runs the HTTP server that is serving files from the
+// directory specified by the 'http_directory` configuration parameter in the
+// template.
 //
 // Uses:
 //   config *config
diff --git a/builder/parallels/pvm/builder.go b/builder/parallels/pvm/builder.go
new file mode 100644
index 000000000..037641619
--- /dev/null
+++ b/builder/parallels/pvm/builder.go
@@ -0,0 +1,138 @@
+package pvm
+
+import (
+	"errors"
+	"fmt"
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"log"
+)
+
+// Builder implements packer.Builder and builds the actual Parallels
+// images.
+type Builder struct {
+	config *Config
+	runner multistep.Runner
+}
+
+// Prepare processes the build configuration parameters.
+func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
+	c, warnings, errs := NewConfig(raws...)
+	if errs != nil {
+		return warnings, errs
+	}
+	b.config = c
+
+	return warnings, nil
+}
+
+// Run executes a Packer build and returns a packer.Artifact representing
+// a Parallels appliance.
+func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	// Create the driver that we'll use to communicate with Parallels
+	driver, err := parallelscommon.NewDriver()
+	if err != nil {
+		return nil, fmt.Errorf("Failed creating Paralles driver: %s", err)
+	}
+
+	// Set up the state.
+	state := new(multistep.BasicStateBag)
+	state.Put("config", b.config)
+	state.Put("driver", driver)
+	state.Put("hook", hook)
+	state.Put("ui", ui)
+	state.Put("http_port", uint(0))
+
+	// Build the steps.
+	steps := []multistep.Step{
+		&parallelscommon.StepPrepareParallelsTools{
+			ParallelsToolsMode:   b.config.ParallelsToolsMode,
+			ParallelsToolsFlavor: b.config.ParallelsToolsFlavor,
+		},
+		&parallelscommon.StepOutputDir{
+			Force: b.config.PackerForce,
+			Path:  b.config.OutputDir,
+		},
+		&common.StepCreateFloppy{
+			Files: b.config.FloppyFiles,
+		},
+		&StepImport{
+			Name:       b.config.VMName,
+			SourcePath: b.config.SourcePath,
+		},
+		&parallelscommon.StepAttachParallelsTools{
+			ParallelsToolsMode: b.config.ParallelsToolsMode,
+		},
+		new(parallelscommon.StepAttachFloppy),
+		&parallelscommon.StepPrlctl{
+			Commands: b.config.Prlctl,
+			Tpl:      b.config.tpl,
+		},
+		&parallelscommon.StepRun{
+			BootWait: b.config.BootWait,
+			Headless: b.config.Headless,
+		},
+		&parallelscommon.StepTypeBootCommand{
+			BootCommand:    b.config.BootCommand,
+			HostInterfaces: []string{},
+			VMName:         b.config.VMName,
+			Tpl:            b.config.tpl,
+		},
+		&common.StepConnectSSH{
+			SSHAddress:     parallelscommon.SSHAddress,
+			SSHConfig:      parallelscommon.SSHConfigFunc(b.config.SSHConfig),
+			SSHWaitTimeout: b.config.SSHWaitTimeout,
+		},
+		&parallelscommon.StepUploadVersion{
+			Path: b.config.PrlctlVersionFile,
+		},
+		&parallelscommon.StepUploadParallelsTools{
+			ParallelsToolsFlavor:    b.config.ParallelsToolsFlavor,
+			ParallelsToolsGuestPath: b.config.ParallelsToolsGuestPath,
+			ParallelsToolsMode:      b.config.ParallelsToolsMode,
+			Tpl:                     b.config.tpl,
+		},
+		new(common.StepProvision),
+		&parallelscommon.StepShutdown{
+			Command: b.config.ShutdownCommand,
+			Timeout: b.config.ShutdownTimeout,
+		},
+	}
+
+	// Run the steps.
+	if b.config.PackerDebug {
+		b.runner = &multistep.DebugRunner{
+			Steps:   steps,
+			PauseFn: common.MultistepDebugFn(ui),
+		}
+	} else {
+		b.runner = &multistep.BasicRunner{Steps: steps}
+	}
+	b.runner.Run(state)
+
+	// Report any errors.
+	if rawErr, ok := state.GetOk("error"); ok {
+		return nil, rawErr.(error)
+	}
+
+	// If we were interrupted or cancelled, then just exit.
+	if _, ok := state.GetOk(multistep.StateCancelled); ok {
+		return nil, errors.New("Build was cancelled.")
+	}
+
+	if _, ok := state.GetOk(multistep.StateHalted); ok {
+		return nil, errors.New("Build was halted.")
+	}
+
+	return parallelscommon.NewArtifact(b.config.OutputDir)
+}
+
+// Cancel.
+func (b *Builder) Cancel() {
+	if b.runner != nil {
+		log.Println("Cancelling the step runner...")
+		b.runner.Cancel()
+	}
+}
diff --git a/builder/parallels/pvm/config.go b/builder/parallels/pvm/config.go
new file mode 100644
index 000000000..83e643111
--- /dev/null
+++ b/builder/parallels/pvm/config.go
@@ -0,0 +1,104 @@
+package pvm
+
+import (
+	"fmt"
+	"os"
+
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+)
+
+// Config is the configuration structure for the builder.
+type Config struct {
+	common.PackerConfig                 `mapstructure:",squash"`
+	parallelscommon.FloppyConfig        `mapstructure:",squash"`
+	parallelscommon.OutputConfig        `mapstructure:",squash"`
+	parallelscommon.PrlctlConfig        `mapstructure:",squash"`
+	parallelscommon.PrlctlVersionConfig `mapstructure:",squash"`
+	parallelscommon.RunConfig           `mapstructure:",squash"`
+	parallelscommon.SSHConfig           `mapstructure:",squash"`
+	parallelscommon.ShutdownConfig      `mapstructure:",squash"`
+	parallelscommon.ToolsConfig         `mapstructure:",squash"`
+
+	BootCommand []string `mapstructure:"boot_command"`
+	SourcePath  string   `mapstructure:"source_path"`
+	VMName      string   `mapstructure:"vm_name"`
+	ReassignMac bool     `mapstructure:"reassign_mac"`
+
+	tpl *packer.ConfigTemplate
+}
+
+func NewConfig(raws ...interface{}) (*Config, []string, error) {
+	c := new(Config)
+	md, err := common.DecodeConfig(c, raws...)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	c.tpl, err = packer.NewConfigTemplate()
+	if err != nil {
+		return nil, nil, err
+	}
+	c.tpl.UserVars = c.PackerUserVars
+
+	if c.VMName == "" {
+		c.VMName = fmt.Sprintf("packer-%s-{{timestamp}}", c.PackerBuildName)
+	}
+
+	// Prepare the errors
+	errs := common.CheckUnusedConfig(md)
+	errs = packer.MultiErrorAppend(errs, c.FloppyConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.OutputConfig.Prepare(c.tpl, &c.PackerConfig)...)
+	errs = packer.MultiErrorAppend(errs, c.PrlctlConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.PrlctlVersionConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.RunConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.ShutdownConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.SSHConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.ToolsConfig.Prepare(c.tpl)...)
+
+	templates := map[string]*string{
+		"source_path": &c.SourcePath,
+		"vm_name":     &c.VMName,
+	}
+
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = c.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	for i, command := range c.BootCommand {
+		if err := c.tpl.Validate(command); err != nil {
+			errs = packer.MultiErrorAppend(errs,
+				fmt.Errorf("Error processing boot_command[%d]: %s", i, err))
+		}
+	}
+
+	if c.SourcePath == "" {
+		errs = packer.MultiErrorAppend(errs, fmt.Errorf("source_path is required"))
+	} else {
+		if _, err := os.Stat(c.SourcePath); err != nil {
+			errs = packer.MultiErrorAppend(errs,
+				fmt.Errorf("source_path is invalid: %s", err))
+		}
+	}
+
+	// Warnings
+	var warnings []string
+	if c.ShutdownCommand == "" {
+		warnings = append(warnings,
+			"A shutdown_command was not specified. Without a shutdown command, Packer\n"+
+				"will forcibly halt the virtual machine, which may result in data loss.")
+	}
+
+	// Check for any errors.
+	if errs != nil && len(errs.Errors) > 0 {
+		return nil, warnings, errs
+	}
+
+	return c, warnings, nil
+}
diff --git a/builder/parallels/pvm/config_test.go b/builder/parallels/pvm/config_test.go
new file mode 100644
index 000000000..c4270c366
--- /dev/null
+++ b/builder/parallels/pvm/config_test.go
@@ -0,0 +1,86 @@
+package pvm
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+)
+
+func testConfig(t *testing.T) map[string]interface{} {
+	return map[string]interface{}{
+		"ssh_username":           "foo",
+		"shutdown_command":       "foo",
+		"parallels_tools_flavor": "lin",
+	}
+}
+
+func getTempFile(t *testing.T) *os.File {
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	tf.Close()
+
+	// don't forget to cleanup the file downstream:
+	// defer os.Remove(tf.Name())
+
+	return tf
+}
+
+func testConfigErr(t *testing.T, warns []string, err error) {
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should error")
+	}
+}
+
+func testConfigOk(t *testing.T, warns []string, err error) {
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("bad: %s", err)
+	}
+}
+
+func TestNewConfig_sourcePath(t *testing.T) {
+	// Bad
+	c := testConfig(t)
+	delete(c, "source_path")
+	_, warns, errs := NewConfig(c)
+	testConfigErr(t, warns, errs)
+
+	// Bad
+	c = testConfig(t)
+	c["source_path"] = "/i/dont/exist"
+	_, warns, errs = NewConfig(c)
+	testConfigErr(t, warns, errs)
+
+	// Good
+	tf := getTempFile(t)
+	defer os.Remove(tf.Name())
+
+	c = testConfig(t)
+	c["source_path"] = tf.Name()
+	_, warns, errs = NewConfig(c)
+	testConfigOk(t, warns, errs)
+}
+
+func TestNewConfig_shutdown_timeout(t *testing.T) {
+	c := testConfig(t)
+	tf := getTempFile(t)
+	defer os.Remove(tf.Name())
+
+	// Expect this to fail
+	c["source_path"] = tf.Name()
+	c["shutdown_timeout"] = "NaN"
+	_, warns, errs := NewConfig(c)
+	testConfigErr(t, warns, errs)
+
+	// Passes when given a valid time duration
+	c["shutdown_timeout"] = "10s"
+	_, warns, errs = NewConfig(c)
+	testConfigOk(t, warns, errs)
+}
diff --git a/builder/parallels/pvm/step_import.go b/builder/parallels/pvm/step_import.go
new file mode 100644
index 000000000..fdff75762
--- /dev/null
+++ b/builder/parallels/pvm/step_import.go
@@ -0,0 +1,48 @@
+package pvm
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/packer"
+)
+
+// This step imports an PVM VM into Parallels.
+type StepImport struct {
+	Name       string
+	SourcePath string
+	vmName     string
+}
+
+func (s *StepImport) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(parallelscommon.Driver)
+	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(*Config)
+
+	ui.Say(fmt.Sprintf("Importing VM: %s", s.SourcePath))
+	if err := driver.Import(s.Name, s.SourcePath, config.OutputDir, config.ReassignMac); err != nil {
+		err := fmt.Errorf("Error importing VM: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	s.vmName = s.Name
+	state.Put("vmName", s.Name)
+	return multistep.ActionContinue
+}
+
+func (s *StepImport) Cleanup(state multistep.StateBag) {
+
+	if s.vmName == "" {
+		return
+	}
+
+	driver := state.Get("driver").(parallelscommon.Driver)
+	ui := state.Get("ui").(packer.Ui)
+
+	ui.Say("Unregistering virtual machine...")
+	if err := driver.Prlctl("unregister", s.vmName); err != nil {
+		ui.Error(fmt.Sprintf("Error unregistering virtual machine: %s", err))
+	}
+}
diff --git a/builder/parallels/pvm/step_test.go b/builder/parallels/pvm/step_test.go
new file mode 100644
index 000000000..15d76de5b
--- /dev/null
+++ b/builder/parallels/pvm/step_test.go
@@ -0,0 +1,19 @@
+package pvm
+
+import (
+	"bytes"
+	"github.com/mitchellh/multistep"
+	parallelscommon "github.com/mitchellh/packer/builder/parallels/common"
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func testState(t *testing.T) multistep.StateBag {
+	state := new(multistep.BasicStateBag)
+	state.Put("driver", new(parallelscommon.DriverMock))
+	state.Put("ui", &packer.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	})
+	return state
+}
diff --git a/builder/qemu/artifact.go b/builder/qemu/artifact.go
index a3f1f9a46..fe7674a47 100644
--- a/builder/qemu/artifact.go
+++ b/builder/qemu/artifact.go
@@ -8,8 +8,9 @@ import (
 // Artifact is the result of running the Qemu builder, namely a set
 // of files associated with the resulting machine.
 type Artifact struct {
-	dir string
-	f   []string
+	dir   string
+	f     []string
+	state map[string]interface{}
 }
 
 func (*Artifact) BuilderId() string {
@@ -28,6 +29,10 @@ func (a *Artifact) String() string {
 	return fmt.Sprintf("VM files in directory: %s", a.dir)
 }
 
+func (a *Artifact) State(name string) interface{} {
+	return a.state[name]
+}
+
 func (a *Artifact) Destroy() error {
 	return os.RemoveAll(a.dir)
 }
diff --git a/builder/qemu/builder.go b/builder/qemu/builder.go
index 7f404a566..1c3d2cdca 100644
--- a/builder/qemu/builder.go
+++ b/builder/qemu/builder.go
@@ -3,41 +3,51 @@ package qemu
 import (
 	"errors"
 	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
 	"strings"
 	"time"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/common"
+	commonssh "github.com/mitchellh/packer/common/ssh"
+	"github.com/mitchellh/packer/packer"
 )
 
 const BuilderId = "transcend.qemu"
 
+var accels = map[string]struct{}{
+	"none": struct{}{},
+	"kvm":  struct{}{},
+	"tcg":  struct{}{},
+	"xen":  struct{}{},
+}
+
 var netDevice = map[string]bool{
-	"ne2k_pci":   true,
-	"i82551":     true,
-	"i82557b":    true,
-	"i82559er":   true,
-	"rtl8139":    true,
-	"e1000":      true,
-	"pcnet":      true,
-	"virtio":     true,
-	"virtio-net": true,
-	"usb-net":    true,
-	"i82559a":    true,
-	"i82559b":    true,
-	"i82559c":    true,
-	"i82550":     true,
-	"i82562":     true,
-	"i82557a":    true,
-	"i82557c":    true,
-	"i82801":     true,
-	"vmxnet3":    true,
-	"i82558a":    true,
-	"i82558b":    true,
+	"ne2k_pci":       true,
+	"i82551":         true,
+	"i82557b":        true,
+	"i82559er":       true,
+	"rtl8139":        true,
+	"e1000":          true,
+	"pcnet":          true,
+	"virtio":         true,
+	"virtio-net":     true,
+	"virtio-net-pci": true,
+	"usb-net":        true,
+	"i82559a":        true,
+	"i82559b":        true,
+	"i82559c":        true,
+	"i82550":         true,
+	"i82562":         true,
+	"i82557a":        true,
+	"i82557c":        true,
+	"i82801":         true,
+	"vmxnet3":        true,
+	"i82558a":        true,
+	"i82558b":        true,
 }
 
 var diskInterface = map[string]bool{
@@ -46,6 +56,14 @@ var diskInterface = map[string]bool{
 	"virtio": true,
 }
 
+var diskCache = map[string]bool{
+	"writethrough": true,
+	"writeback":    true,
+	"none":         true,
+	"unsafe":       true,
+	"directsync":   true,
+}
+
 type Builder struct {
 	config config
 	runner multistep.Runner
@@ -58,15 +76,18 @@ type config struct {
 	BootCommand     []string   `mapstructure:"boot_command"`
 	DiskInterface   string     `mapstructure:"disk_interface"`
 	DiskSize        uint       `mapstructure:"disk_size"`
+	DiskCache       string     `mapstructure:"disk_cache"`
 	FloppyFiles     []string   `mapstructure:"floppy_files"`
 	Format          string     `mapstructure:"format"`
 	Headless        bool       `mapstructure:"headless"`
+	DiskImage       bool       `mapstructure:"disk_image"`
 	HTTPDir         string     `mapstructure:"http_directory"`
 	HTTPPortMin     uint       `mapstructure:"http_port_min"`
 	HTTPPortMax     uint       `mapstructure:"http_port_max"`
 	ISOChecksum     string     `mapstructure:"iso_checksum"`
 	ISOChecksumType string     `mapstructure:"iso_checksum_type"`
 	ISOUrls         []string   `mapstructure:"iso_urls"`
+	MachineType     string     `mapstructure:"machine_type"`
 	NetDevice       string     `mapstructure:"net_device"`
 	OutputDir       string     `mapstructure:"output_directory"`
 	QemuArgs        [][]string `mapstructure:"qemuargs"`
@@ -115,6 +136,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.DiskSize = 40000
 	}
 
+	if b.config.DiskCache == "" {
+		b.config.DiskCache = "writeback"
+	}
+
 	if b.config.Accelerator == "" {
 		b.config.Accelerator = "kvm"
 	}
@@ -127,6 +152,10 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.HTTPPortMax = 9000
 	}
 
+	if b.config.MachineType == "" {
+		b.config.MachineType = "pc"
+	}
+
 	if b.config.OutputDir == "" {
 		b.config.OutputDir = fmt.Sprintf("output-%s", b.config.PackerBuildName)
 	}
@@ -205,6 +234,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		"shutdown_timeout":  &b.config.RawShutdownTimeout,
 		"ssh_wait_timeout":  &b.config.RawSSHWaitTimeout,
 		"accelerator":       &b.config.Accelerator,
+		"machine_type":      &b.config.MachineType,
 		"net_device":        &b.config.NetDevice,
 		"disk_interface":    &b.config.DiskInterface,
 	}
@@ -249,9 +279,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			errs, errors.New("invalid format, only 'qcow2' or 'raw' are allowed"))
 	}
 
-	if !(b.config.Accelerator == "kvm" || b.config.Accelerator == "xen") {
+	if _, ok := accels[b.config.Accelerator]; !ok {
 		errs = packer.MultiErrorAppend(
-			errs, errors.New("invalid format, only 'kvm' or 'xen' are allowed"))
+			errs, errors.New("invalid accelerator, only 'kvm', 'tcg', 'xen', or 'none' are allowed"))
 	}
 
 	if _, ok := netDevice[b.config.NetDevice]; !ok {
@@ -264,6 +294,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			errs, errors.New("unrecognized disk interface type"))
 	}
 
+	if _, ok := diskCache[b.config.DiskCache]; !ok {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("unrecognized disk cache type"))
+	}
+
 	if b.config.HTTPPortMin > b.config.HTTPPortMax {
 		errs = packer.MultiErrorAppend(
 			errs, errors.New("http_port_min must be less than http_port_max"))
@@ -338,7 +373,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		if _, err := os.Stat(b.config.SSHKeyPath); err != nil {
 			errs = packer.MultiErrorAppend(
 				errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		} else if _, err := sshKeyToSigner(b.config.SSHKeyPath); err != nil {
+		} else if _, err := commonssh.FileSigner(b.config.SSHKeyPath); err != nil {
 			errs = packer.MultiErrorAppend(
 				errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
 		}
@@ -396,6 +431,8 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			Files: b.config.FloppyFiles,
 		},
 		new(stepCreateDisk),
+		new(stepCopyDisk),
+		new(stepResizeDisk),
 		new(stepHTTPServer),
 		new(stepForwardSSH),
 		new(stepConfigureVNC),
@@ -463,10 +500,16 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	}
 
 	artifact := &Artifact{
-		dir: b.config.OutputDir,
-		f:   files,
+		dir:   b.config.OutputDir,
+		f:     files,
+		state: make(map[string]interface{}),
 	}
 
+	artifact.state["diskName"] = state.Get("disk_filename").(string)
+	artifact.state["diskType"] = b.config.Format
+	artifact.state["diskSize"] = uint64(b.config.DiskSize)
+	artifact.state["domainType"] = b.config.Accelerator
+
 	return artifact, nil
 }
 
diff --git a/builder/qemu/ssh.go b/builder/qemu/ssh.go
index d22f611bc..de7858166 100644
--- a/builder/qemu/ssh.go
+++ b/builder/qemu/ssh.go
@@ -1,12 +1,12 @@
 package qemu
 
 import (
-	gossh "code.google.com/p/go.crypto/ssh"
 	"fmt"
+
+	gossh "code.google.com/p/go.crypto/ssh"
 	"github.com/mitchellh/multistep"
+	commonssh "github.com/mitchellh/packer/common/ssh"
 	"github.com/mitchellh/packer/communicator/ssh"
-	"io/ioutil"
-	"os"
 )
 
 func sshAddress(state multistep.StateBag) (string, error) {
@@ -24,7 +24,7 @@ func sshConfig(state multistep.StateBag) (*gossh.ClientConfig, error) {
 	}
 
 	if config.SSHKeyPath != "" {
-		signer, err := sshKeyToSigner(config.SSHKeyPath)
+		signer, err := commonssh.FileSigner(config.SSHKeyPath)
 		if err != nil {
 			return nil, err
 		}
@@ -37,23 +37,3 @@ func sshConfig(state multistep.StateBag) (*gossh.ClientConfig, error) {
 		Auth: auth,
 	}, nil
 }
-
-func sshKeyToSigner(path string) (gossh.Signer, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	keyBytes, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, err
-	}
-
-	signer, err := gossh.ParsePrivateKey(keyBytes)
-	if err != nil {
-		return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-	}
-
-	return signer, nil
-}
diff --git a/builder/qemu/step_copy_disk.go b/builder/qemu/step_copy_disk.go
new file mode 100644
index 000000000..7f2efe30e
--- /dev/null
+++ b/builder/qemu/step_copy_disk.go
@@ -0,0 +1,45 @@
+package qemu
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"path/filepath"
+	"strings"
+)
+
+// This step copies the virtual disk that will be used as the
+// hard drive for the virtual machine.
+type stepCopyDisk struct{}
+
+func (s *stepCopyDisk) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*config)
+	driver := state.Get("driver").(Driver)
+	isoPath := state.Get("iso_path").(string)
+	ui := state.Get("ui").(packer.Ui)
+	path := filepath.Join(config.OutputDir, fmt.Sprintf("%s.%s", config.VMName,
+		strings.ToLower(config.Format)))
+
+	command := []string{
+		"convert",
+		"-f", config.Format,
+		isoPath,
+		path,
+	}
+
+	if config.DiskImage == false {
+		return multistep.ActionContinue
+	}
+
+	ui.Say("Copying hard drive...")
+	if err := driver.QemuImg(command...); err != nil {
+		err := fmt.Errorf("Error creating hard drive: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *stepCopyDisk) Cleanup(state multistep.StateBag) {}
diff --git a/builder/qemu/step_create_disk.go b/builder/qemu/step_create_disk.go
index 7e6f09b7d..986df1d2b 100644
--- a/builder/qemu/step_create_disk.go
+++ b/builder/qemu/step_create_disk.go
@@ -16,8 +16,8 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 	config := state.Get("config").(*config)
 	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
-	path := filepath.Join(config.OutputDir, fmt.Sprintf("%s.%s", config.VMName,
-		strings.ToLower(config.Format)))
+	name := config.VMName + "." + strings.ToLower(config.Format)
+	path := filepath.Join(config.OutputDir, name)
 
 	command := []string{
 		"create",
@@ -26,6 +26,10 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 		fmt.Sprintf("%vM", config.DiskSize),
 	}
 
+	if config.DiskImage == true {
+		return multistep.ActionContinue
+	}
+
 	ui.Say("Creating hard drive...")
 	if err := driver.QemuImg(command...); err != nil {
 		err := fmt.Errorf("Error creating hard drive: %s", err)
@@ -34,6 +38,8 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
+	state.Put("disk_filename", name)
+
 	return multistep.ActionContinue
 }
 
diff --git a/builder/qemu/step_forward_ssh.go b/builder/qemu/step_forward_ssh.go
index 7c7925b17..3b84d26c1 100644
--- a/builder/qemu/step_forward_ssh.go
+++ b/builder/qemu/step_forward_ssh.go
@@ -2,11 +2,12 @@ package qemu
 
 import (
 	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"math/rand"
 	"net"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // This step adds a NAT port forwarding definition so that SSH is available
@@ -23,9 +24,16 @@ func (s *stepForwardSSH) Run(state multistep.StateBag) multistep.StepAction {
 
 	log.Printf("Looking for available SSH port between %d and %d", config.SSHHostPortMin, config.SSHHostPortMax)
 	var sshHostPort uint
+	var offset uint = 0
+
 	portRange := int(config.SSHHostPortMax - config.SSHHostPortMin)
+	if portRange > 0 {
+		// Have to check if > 0 to avoid a panic
+		offset = uint(rand.Intn(portRange))
+	}
+
 	for {
-		sshHostPort = uint(rand.Intn(portRange)) + config.SSHHostPortMin
+		sshHostPort = offset + config.SSHHostPortMin
 		log.Printf("Trying port: %d", sshHostPort)
 		l, err := net.Listen("tcp", fmt.Sprintf(":%d", sshHostPort))
 		if err == nil {
diff --git a/builder/qemu/step_http_server.go b/builder/qemu/step_http_server.go
index 08a4bd7fa..831253853 100644
--- a/builder/qemu/step_http_server.go
+++ b/builder/qemu/step_http_server.go
@@ -10,8 +10,9 @@ import (
 	"net/http"
 )
 
-// This step creates and runs the HTTP server that is serving the files
-// specified by the 'http_files` configuration parameter in the template.
+// This step creates and runs the HTTP server that is serving files from the
+// directory specified by the 'http_directory` configuration parameter in the
+// template.
 //
 // Uses:
 //   config *config
diff --git a/builder/qemu/step_resize_disk.go b/builder/qemu/step_resize_disk.go
new file mode 100644
index 000000000..4e8536c32
--- /dev/null
+++ b/builder/qemu/step_resize_disk.go
@@ -0,0 +1,43 @@
+package qemu
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"path/filepath"
+	"strings"
+)
+
+// This step resizes the virtual disk that will be used as the
+// hard drive for the virtual machine.
+type stepResizeDisk struct{}
+
+func (s *stepResizeDisk) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*config)
+	driver := state.Get("driver").(Driver)
+	ui := state.Get("ui").(packer.Ui)
+	path := filepath.Join(config.OutputDir, fmt.Sprintf("%s.%s", config.VMName,
+		strings.ToLower(config.Format)))
+
+	command := []string{
+		"resize",
+		path,
+		fmt.Sprintf("%vM", config.DiskSize),
+	}
+
+	if config.DiskImage == false {
+		return multistep.ActionContinue
+	}
+
+	ui.Say("Resizing hard drive...")
+	if err := driver.QemuImg(command...); err != nil {
+		err := fmt.Errorf("Error creating hard drive: %s", err)
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	return multistep.ActionContinue
+}
+
+func (s *stepResizeDisk) Cleanup(state multistep.StateBag) {}
diff --git a/builder/qemu/step_run.go b/builder/qemu/step_run.go
index 858c8424c..bb2876f86 100644
--- a/builder/qemu/step_run.go
+++ b/builder/qemu/step_run.go
@@ -2,11 +2,12 @@ package qemu
 
 import (
 	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"path/filepath"
 	"strings"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // stepRun runs the virtual machine
@@ -61,32 +62,39 @@ func getCommandArgs(bootDrive string, state multistep.StateBag) ([]string, error
 	sshHostPort := state.Get("sshHostPort").(uint)
 	ui := state.Get("ui").(packer.Ui)
 
-	guiArgument := "sdl"
 	vnc := fmt.Sprintf("0.0.0.0:%d", vncPort-5900)
 	vmName := config.VMName
 	imgPath := filepath.Join(config.OutputDir,
 		fmt.Sprintf("%s.%s", vmName, strings.ToLower(config.Format)))
 
+	defaultArgs := make(map[string]string)
+
 	if config.Headless == true {
 		ui.Message("WARNING: The VM will be started in headless mode, as configured.\n" +
 			"In headless mode, errors during the boot sequence or OS setup\n" +
 			"won't be easily visible. Use at your own discretion.")
-		guiArgument = "none"
+	} else {
+		defaultArgs["-display"] = "sdl"
 	}
 
-	defaultArgs := make(map[string]string)
 	defaultArgs["-name"] = vmName
-	defaultArgs["-machine"] = fmt.Sprintf("type=pc-1.0,accel=%s", config.Accelerator)
-	defaultArgs["-display"] = guiArgument
-	defaultArgs["-netdev"] = "user,id=user.0"
+	defaultArgs["-machine"] = fmt.Sprintf("type=%s", config.MachineType)
+	defaultArgs["-netdev"] = fmt.Sprintf("user,id=user.0,hostfwd=tcp::%v-:22", sshHostPort)
 	defaultArgs["-device"] = fmt.Sprintf("%s,netdev=user.0", config.NetDevice)
-	defaultArgs["-drive"] = fmt.Sprintf("file=%s,if=%s", imgPath, config.DiskInterface)
+	defaultArgs["-drive"] = fmt.Sprintf("file=%s,if=%s,cache=%s", imgPath, config.DiskInterface, config.DiskCache)
 	defaultArgs["-cdrom"] = isoPath
 	defaultArgs["-boot"] = bootDrive
-	defaultArgs["-m"] = "512m"
-	defaultArgs["-redir"] = fmt.Sprintf("tcp:%v::22", sshHostPort)
+	defaultArgs["-m"] = "512M"
 	defaultArgs["-vnc"] = vnc
 
+	// Append the accelerator to the machine type if it is specified
+	if config.Accelerator != "none" {
+		defaultArgs["-machine"] += fmt.Sprintf(",accel=%s", config.Accelerator)
+	} else {
+		ui.Message("WARNING: The VM will be started with no hardware acceleration.\n" +
+			"The installation may take considerably longer to finish.\n")
+	}
+
 	// Determine if we have a floppy disk to attach
 	if floppyPathRaw, ok := state.GetOk("floppy_path"); ok {
 		defaultArgs["-fda"] = floppyPathRaw.(string)
diff --git a/builder/virtualbox/common/artifact.go b/builder/virtualbox/common/artifact.go
index f4fc48100..9755c7a44 100644
--- a/builder/virtualbox/common/artifact.go
+++ b/builder/virtualbox/common/artifact.go
@@ -56,6 +56,10 @@ func (a *artifact) String() string {
 	return fmt.Sprintf("VM files in directory: %s", a.dir)
 }
 
+func (a *artifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *artifact) Destroy() error {
 	return os.RemoveAll(a.dir)
 }
diff --git a/builder/virtualbox/common/driver.go b/builder/virtualbox/common/driver.go
index 8c389d419..a55b20199 100644
--- a/builder/virtualbox/common/driver.go
+++ b/builder/virtualbox/common/driver.go
@@ -23,7 +23,10 @@ type Driver interface {
 	Delete(string) error
 
 	// Import a VM
-	Import(string, string, string) error
+	Import(string, string, []string) error
+
+	// The complete path to the Guest Additions ISO
+	Iso() (string, error)
 
 	// Checks if the VM with the given name is running.
 	IsRunning(string) (bool, error)
@@ -52,15 +55,16 @@ func NewDriver() (Driver, error) {
 
 	// On Windows, we check VBOX_INSTALL_PATH env var for the path
 	if runtime.GOOS == "windows" {
-		if installPath := os.Getenv("VBOX_INSTALL_PATH"); installPath != "" {
-			log.Printf("[DEBUG] builder/virtualbox: VBOX_INSTALL_PATH: %s",
-				installPath)
-			for _, path := range strings.Split(installPath, ";") {
-				path = filepath.Join(path, "VBoxManage.exe")
-				if _, err := os.Stat(path); err == nil {
-					vboxmanagePath = path
-					break
-				}
+		vars := []string{"VBOX_INSTALL_PATH", "VBOX_MSI_INSTALL_PATH"}
+		for _, key := range vars {
+			value := os.Getenv(key)
+			if value != "" {
+				log.Printf(
+					"[DEBUG] builder/virtualbox: %s = %s", key, value)
+				vboxmanagePath = findVBoxManageWindows(value)
+			}
+			if vboxmanagePath != "" {
+				break
 			}
 		}
 	}
@@ -81,3 +85,14 @@ func NewDriver() (Driver, error) {
 
 	return driver, nil
 }
+
+func findVBoxManageWindows(paths string) string {
+	for _, path := range strings.Split(paths, ";") {
+		path = filepath.Join(path, "VBoxManage.exe")
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+	}
+
+	return ""
+}
diff --git a/builder/virtualbox/common/driver_4_2.go b/builder/virtualbox/common/driver_4_2.go
index 49609d059..3462933cd 100644
--- a/builder/virtualbox/common/driver_4_2.go
+++ b/builder/virtualbox/common/driver_4_2.go
@@ -40,13 +40,43 @@ func (d *VBox42Driver) Delete(name string) error {
 	return d.VBoxManage("unregistervm", name, "--delete")
 }
 
-func (d *VBox42Driver) Import(name, path, opts string) error {
+func (d *VBox42Driver) Iso() (string, error) {
+	var stdout bytes.Buffer
+
+	cmd := exec.Command(d.VBoxManagePath, "list", "systemproperties")
+	cmd.Stdout = &stdout
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+
+	DefaultGuestAdditionsRe := regexp.MustCompile("Default Guest Additions ISO:(.+)")
+
+	for _, line := range strings.Split(stdout.String(), "\n") {
+		// Need to trim off CR character when running in windows
+		// Trimming whitespaces at this point helps to filter out empty value
+		line = strings.TrimRight(line, " \r")
+
+		matches := DefaultGuestAdditionsRe.FindStringSubmatch(line)
+		if matches == nil {
+			continue
+		}
+
+		isoname := strings.Trim(matches[1], " \r\n")
+		log.Printf("Found Default Guest Additions ISO: %s", isoname)
+
+		return isoname, nil
+	}
+
+	return "", fmt.Errorf("Cannot find \"Default Guest Additions ISO\" in vboxmanage output (or it is empty)")
+}
+
+func (d *VBox42Driver) Import(name string, path string, flags []string) error {
 	args := []string{
 		"import", path,
 		"--vsys", "0",
 		"--vmname", name,
-		"--options", opts,
 	}
+	args = append(args, flags...)
 
 	return d.VBoxManage(args...)
 }
@@ -128,6 +158,15 @@ func (d *VBox42Driver) VBoxManage(args ...string) error {
 		err = fmt.Errorf("VBoxManage error: %s", stderrString)
 	}
 
+	if err == nil {
+		// Sometimes VBoxManage gives us an error with a zero exit code,
+		// so we also regexp match an error string.
+		m, _ := regexp.MatchString("VBoxManage([.a-z]+?): error:", stderrString)
+		if m {
+			err = fmt.Errorf("VBoxManage error: %s", stderrString)
+		}
+	}
+
 	log.Printf("stdout: %s", stdoutString)
 	log.Printf("stderr: %s", stderrString)
 
@@ -157,12 +196,12 @@ func (d *VBox42Driver) Version() (string, error) {
 		return "", fmt.Errorf("VirtualBox is not properly setup: %s", versionOutput)
 	}
 
-	versionRe := regexp.MustCompile("[^.0-9]")
-	matches := versionRe.Split(versionOutput, 2)
-	if len(matches) == 0 || matches[0] == "" {
+	versionRe := regexp.MustCompile("^([.0-9]+)(?:_(?:RC|OSEr)[0-9]+)?")
+	matches := versionRe.FindAllStringSubmatch(versionOutput, 1)
+	if matches == nil || len(matches[0]) != 2 {
 		return "", fmt.Errorf("No version found: %s", versionOutput)
 	}
 
-	log.Printf("VirtualBox version: %s", matches[0])
-	return matches[0], nil
+	log.Printf("VirtualBox version: %s", matches[0][1])
+	return matches[0][1], nil
 }
diff --git a/builder/virtualbox/common/driver_mock.go b/builder/virtualbox/common/driver_mock.go
index 39d0ebb5d..1aacf9f8f 100644
--- a/builder/virtualbox/common/driver_mock.go
+++ b/builder/virtualbox/common/driver_mock.go
@@ -16,9 +16,12 @@ type DriverMock struct {
 	ImportCalled bool
 	ImportName   string
 	ImportPath   string
-	ImportOpts   string
+	ImportFlags  []string
 	ImportErr    error
 
+	IsoCalled bool
+	IsoErr    error
+
 	IsRunningName   string
 	IsRunningReturn bool
 	IsRunningErr    error
@@ -52,14 +55,19 @@ func (d *DriverMock) Delete(name string) error {
 	return d.DeleteErr
 }
 
-func (d *DriverMock) Import(name, path, opts string) error {
+func (d *DriverMock) Import(name string, path string, flags []string) error {
 	d.ImportCalled = true
 	d.ImportName = name
 	d.ImportPath = path
-	d.ImportOpts = opts
+	d.ImportFlags = flags
 	return d.ImportErr
 }
 
+func (d *DriverMock) Iso() (string, error) {
+	d.IsoCalled = true
+	return "", d.IsoErr
+}
+
 func (d *DriverMock) IsRunning(name string) (bool, error) {
 	d.Lock()
 	defer d.Unlock()
diff --git a/builder/virtualbox/common/guest_addition_modes.go b/builder/virtualbox/common/guest_addition_modes.go
new file mode 100644
index 000000000..b713df7c8
--- /dev/null
+++ b/builder/virtualbox/common/guest_addition_modes.go
@@ -0,0 +1,9 @@
+package common
+
+// These are the different valid mode values for "guest_additions_mode" which
+// determine how guest additions are delivered to the guest.
+const (
+	GuestAdditionsModeDisable string = "disable"
+	GuestAdditionsModeAttach         = "attach"
+	GuestAdditionsModeUpload         = "upload"
+)
diff --git a/builder/virtualbox/common/run_config.go b/builder/virtualbox/common/run_config.go
index 755d0f1c1..b024189a6 100644
--- a/builder/virtualbox/common/run_config.go
+++ b/builder/virtualbox/common/run_config.go
@@ -1,15 +1,21 @@
 package common
 
 import (
+	"errors"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
 	"time"
+
+	"github.com/mitchellh/packer/packer"
 )
 
 type RunConfig struct {
 	Headless    bool   `mapstructure:"headless"`
 	RawBootWait string `mapstructure:"boot_wait"`
 
+	HTTPDir     string `mapstructure:"http_directory"`
+	HTTPPortMin uint   `mapstructure:"http_port_min"`
+	HTTPPortMax uint   `mapstructure:"http_port_max"`
+
 	BootWait time.Duration ``
 }
 
@@ -18,8 +24,17 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		c.RawBootWait = "10s"
 	}
 
+	if c.HTTPPortMin == 0 {
+		c.HTTPPortMin = 8000
+	}
+
+	if c.HTTPPortMax == 0 {
+		c.HTTPPortMax = 9000
+	}
+
 	templates := map[string]*string{
-		"boot_wait": &c.RawBootWait,
+		"boot_wait":      &c.RawBootWait,
+		"http_directory": &c.HTTPDir,
 	}
 
 	errs := make([]error, 0)
@@ -37,5 +52,10 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		errs = append(errs, fmt.Errorf("Failed parsing boot_wait: %s", err))
 	}
 
+	if c.HTTPPortMin > c.HTTPPortMax {
+		errs = append(errs,
+			errors.New("http_port_min must be less than http_port_max"))
+	}
+
 	return errs
 }
diff --git a/builder/virtualbox/common/ssh.go b/builder/virtualbox/common/ssh.go
index 41188bf45..0cfc05d2c 100644
--- a/builder/virtualbox/common/ssh.go
+++ b/builder/virtualbox/common/ssh.go
@@ -1,12 +1,12 @@
 package common
 
 import (
-	gossh "code.google.com/p/go.crypto/ssh"
 	"fmt"
+
+	gossh "code.google.com/p/go.crypto/ssh"
 	"github.com/mitchellh/multistep"
+	commonssh "github.com/mitchellh/packer/common/ssh"
 	"github.com/mitchellh/packer/communicator/ssh"
-	"io/ioutil"
-	"os"
 )
 
 func SSHAddress(state multistep.StateBag) (string, error) {
@@ -23,7 +23,7 @@ func SSHConfigFunc(config SSHConfig) func(multistep.StateBag) (*gossh.ClientConf
 		}
 
 		if config.SSHKeyPath != "" {
-			signer, err := sshKeyToSigner(config.SSHKeyPath)
+			signer, err := commonssh.FileSigner(config.SSHKeyPath)
 			if err != nil {
 				return nil, err
 			}
@@ -37,23 +37,3 @@ func SSHConfigFunc(config SSHConfig) func(multistep.StateBag) (*gossh.ClientConf
 		}, nil
 	}
 }
-
-func sshKeyToSigner(path string) (gossh.Signer, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	keyBytes, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, err
-	}
-
-	signer, err := gossh.ParsePrivateKey(keyBytes)
-	if err != nil {
-		return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-	}
-
-	return signer, nil
-}
diff --git a/builder/virtualbox/common/ssh_config.go b/builder/virtualbox/common/ssh_config.go
index 5da8ad403..662ee9c8e 100644
--- a/builder/virtualbox/common/ssh_config.go
+++ b/builder/virtualbox/common/ssh_config.go
@@ -3,9 +3,11 @@ package common
 import (
 	"errors"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
 	"os"
 	"time"
+
+	commonssh "github.com/mitchellh/packer/common/ssh"
+	"github.com/mitchellh/packer/packer"
 )
 
 type SSHConfig struct {
@@ -57,7 +59,7 @@ func (c *SSHConfig) Prepare(t *packer.ConfigTemplate) []error {
 	if c.SSHKeyPath != "" {
 		if _, err := os.Stat(c.SSHKeyPath); err != nil {
 			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		} else if _, err := sshKeyToSigner(c.SSHKeyPath); err != nil {
+		} else if _, err := commonssh.FileSigner(c.SSHKeyPath); err != nil {
 			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
 		}
 	}
diff --git a/builder/virtualbox/iso/step_attach_guest_additions.go b/builder/virtualbox/common/step_attach_guest_additions.go
similarity index 79%
rename from builder/virtualbox/iso/step_attach_guest_additions.go
rename to builder/virtualbox/common/step_attach_guest_additions.go
index f35710259..bb047ed9a 100644
--- a/builder/virtualbox/iso/step_attach_guest_additions.go
+++ b/builder/virtualbox/common/step_attach_guest_additions.go
@@ -1,9 +1,8 @@
-package iso
+package common
 
 import (
 	"fmt"
 	"github.com/mitchellh/multistep"
-	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/packer"
 	"log"
 )
@@ -19,18 +18,18 @@ import (
 //   vmName string
 //
 // Produces:
-type stepAttachGuestAdditions struct {
-	attachedPath string
+type StepAttachGuestAdditions struct {
+	attachedPath       string
+	GuestAdditionsMode string
 }
 
-func (s *stepAttachGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vboxcommon.Driver)
+func (s *StepAttachGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
 	vmName := state.Get("vmName").(string)
 
 	// If we're not attaching the guest additions then just return
-	if config.GuestAdditionsMode != GuestAdditionsModeAttach {
+	if s.GuestAdditionsMode != GuestAdditionsModeAttach {
 		log.Println("Not attaching guest additions since we're uploading.")
 		return multistep.ActionContinue
 	}
@@ -61,12 +60,12 @@ func (s *stepAttachGuestAdditions) Run(state multistep.StateBag) multistep.StepA
 	return multistep.ActionContinue
 }
 
-func (s *stepAttachGuestAdditions) Cleanup(state multistep.StateBag) {
+func (s *StepAttachGuestAdditions) Cleanup(state multistep.StateBag) {
 	if s.attachedPath == "" {
 		return
 	}
 
-	driver := state.Get("driver").(vboxcommon.Driver)
+	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
 	vmName := state.Get("vmName").(string)
 
diff --git a/builder/virtualbox/iso/step_download_guest_additions.go b/builder/virtualbox/common/step_download_guest_additions.go
similarity index 76%
rename from builder/virtualbox/iso/step_download_guest_additions.go
rename to builder/virtualbox/common/step_download_guest_additions.go
index dbb8b9d3c..029c7d85b 100644
--- a/builder/virtualbox/iso/step_download_guest_additions.go
+++ b/builder/virtualbox/common/step_download_guest_additions.go
@@ -1,10 +1,9 @@
-package iso
+package common
 
 import (
 	"bytes"
 	"fmt"
 	"github.com/mitchellh/multistep"
-	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
 	"io"
@@ -28,16 +27,20 @@ type guestAdditionsUrlTemplate struct {
 //
 // Produces:
 //   guest_additions_path string - Path to the guest additions.
-type stepDownloadGuestAdditions struct{}
+type StepDownloadGuestAdditions struct {
+	GuestAdditionsMode   string
+	GuestAdditionsURL    string
+	GuestAdditionsSHA256 string
+	Tpl                  *packer.ConfigTemplate
+}
 
-func (s *stepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
+func (s *StepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
 	var action multistep.StepAction
-	driver := state.Get("driver").(vboxcommon.Driver)
+	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
-	config := state.Get("config").(*config)
 
 	// If we've disabled guest additions, don't download
-	if config.GuestAdditionsMode == GuestAdditionsModeDisable {
+	if s.GuestAdditionsMode == GuestAdditionsModeDisable {
 		log.Println("Not downloading guest additions since it is disabled.")
 		return multistep.ActionContinue
 	}
@@ -59,23 +62,16 @@ func (s *stepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.Ste
 	// Use provided version or get it from virtualbox.org
 	var checksum string
 
-	if config.GuestAdditionsSHA256 != "" {
-		checksum = config.GuestAdditionsSHA256
-	} else {
-		checksum, action = s.downloadAdditionsSHA256(state, version, additionsName)
-		if action != multistep.ActionContinue {
-			return action
-		}
-	}
+	checksumType := "sha256"
 
 	// Use the provided source (URL or file path) or generate it
-	url := config.GuestAdditionsURL
+	url := s.GuestAdditionsURL
 	if url != "" {
 		tplData := &guestAdditionsUrlTemplate{
 			Version: version,
 		}
 
-		url, err = config.tpl.Process(url, tplData)
+		url, err = s.Tpl.Process(url, tplData)
 		if err != nil {
 			err := fmt.Errorf("Error preparing guest additions url: %s", err)
 			state.Put("error", err)
@@ -83,10 +79,35 @@ func (s *stepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.Ste
 			return multistep.ActionHalt
 		}
 	} else {
-		url = fmt.Sprintf(
-			"http://download.virtualbox.org/virtualbox/%s/%s",
-			version,
-			additionsName)
+		url, err = driver.Iso()
+
+		if err == nil {
+			checksumType = "none"
+		} else {
+			ui.Error(err.Error())
+			url = fmt.Sprintf(
+				"http://download.virtualbox.org/virtualbox/%s/%s",
+				version,
+				additionsName)
+		}
+	}
+	if url == "" {
+		err := fmt.Errorf("Couldn't detect guest additions URL.\n" +
+			"Please specify `guest_additions_url` manually.")
+		state.Put("error", err)
+		ui.Error(err.Error())
+		return multistep.ActionHalt
+	}
+
+	if checksumType != "none" {
+		if s.GuestAdditionsSHA256 != "" {
+			checksum = s.GuestAdditionsSHA256
+		} else {
+			checksum, action = s.downloadAdditionsSHA256(state, version, additionsName)
+			if action != multistep.ActionContinue {
+				return action
+			}
+		}
 	}
 
 	url, err = common.DownloadableURL(url)
@@ -101,7 +122,7 @@ func (s *stepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.Ste
 
 	downStep := &common.StepDownload{
 		Checksum:     checksum,
-		ChecksumType: "sha256",
+		ChecksumType: checksumType,
 		Description:  "Guest additions",
 		ResultKey:    "guest_additions_path",
 		Url:          []string{url},
@@ -110,9 +131,9 @@ func (s *stepDownloadGuestAdditions) Run(state multistep.StateBag) multistep.Ste
 	return downStep.Run(state)
 }
 
-func (s *stepDownloadGuestAdditions) Cleanup(state multistep.StateBag) {}
+func (s *StepDownloadGuestAdditions) Cleanup(state multistep.StateBag) {}
 
-func (s *stepDownloadGuestAdditions) downloadAdditionsSHA256(state multistep.StateBag, additionsVersion string, additionsName string) (string, multistep.StepAction) {
+func (s *StepDownloadGuestAdditions) downloadAdditionsSHA256(state multistep.StateBag, additionsVersion string, additionsName string) (string, multistep.StepAction) {
 	// First things first, we get the list of checksums for the files available
 	// for this version.
 	checksumsUrl := fmt.Sprintf(
diff --git a/builder/virtualbox/common/step_http_server.go b/builder/virtualbox/common/step_http_server.go
new file mode 100644
index 000000000..440d9adbc
--- /dev/null
+++ b/builder/virtualbox/common/step_http_server.go
@@ -0,0 +1,78 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"math/rand"
+	"net"
+	"net/http"
+)
+
+// This step creates and runs the HTTP server that is serving files from the
+// directory specified by the 'http_directory` configuration parameter in the
+// template.
+//
+// Uses:
+//   ui     packer.Ui
+//
+// Produces:
+//   http_port int - The port the HTTP server started on.
+type StepHTTPServer struct {
+	HTTPDir     string
+	HTTPPortMin uint
+	HTTPPortMax uint
+
+	l net.Listener
+}
+
+func (s *StepHTTPServer) Run(state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
+
+	var httpPort uint = 0
+	if s.HTTPDir == "" {
+		state.Put("http_port", httpPort)
+		return multistep.ActionContinue
+	}
+
+	// Find an available TCP port for our HTTP server
+	var httpAddr string
+	portRange := int(s.HTTPPortMax - s.HTTPPortMin)
+	for {
+		var err error
+		var offset uint = 0
+
+		if portRange > 0 {
+			// Intn will panic if portRange == 0, so we do a check.
+			offset = uint(rand.Intn(portRange))
+		}
+
+		httpPort = offset + s.HTTPPortMin
+		httpAddr = fmt.Sprintf(":%d", httpPort)
+		log.Printf("Trying port: %d", httpPort)
+		s.l, err = net.Listen("tcp", httpAddr)
+		if err == nil {
+			break
+		}
+	}
+
+	ui.Say(fmt.Sprintf("Starting HTTP server on port %d", httpPort))
+
+	// Start the HTTP server and run it in the background
+	fileServer := http.FileServer(http.Dir(s.HTTPDir))
+	server := &http.Server{Addr: httpAddr, Handler: fileServer}
+	go server.Serve(s.l)
+
+	// Save the address into the state so it can be accessed in the future
+	state.Put("http_port", httpPort)
+
+	return multistep.ActionContinue
+}
+
+func (s *StepHTTPServer) Cleanup(multistep.StateBag) {
+	if s.l != nil {
+		// Close the listener so that the HTTP server stops
+		s.l.Close()
+	}
+}
diff --git a/builder/virtualbox/common/step_remove_devices.go b/builder/virtualbox/common/step_remove_devices.go
index 2a11dcbba..8f06b1a61 100644
--- a/builder/virtualbox/common/step_remove_devices.go
+++ b/builder/virtualbox/common/step_remove_devices.go
@@ -41,11 +41,20 @@ func (s *StepRemoveDevices) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	if _, ok := state.GetOk("attachedIso"); ok {
+		controllerName := "IDE Controller"
+		port := "0"
+		device := "1"
+		if _, ok := state.GetOk("attachedIsoOnSata"); ok {
+			controllerName = "SATA Controller"
+			port = "1"
+			device = "0"
+		}
+
 		command := []string{
 			"storageattach", vmName,
-			"--storagectl", "IDE Controller",
-			"--port", "0",
-			"--device", "1",
+			"--storagectl", controllerName,
+			"--port", port,
+			"--device", device,
 			"--medium", "none",
 		}
 
diff --git a/builder/virtualbox/common/step_remove_devices_test.go b/builder/virtualbox/common/step_remove_devices_test.go
index e74331232..e3df5e6e7 100644
--- a/builder/virtualbox/common/step_remove_devices_test.go
+++ b/builder/virtualbox/common/step_remove_devices_test.go
@@ -57,6 +57,33 @@ func TestStepRemoveDevices_attachedIso(t *testing.T) {
 	}
 }
 
+func TestStepRemoveDevices_attachedIsoOnSata(t *testing.T) {
+	state := testState(t)
+	step := new(StepRemoveDevices)
+
+	state.Put("attachedIso", true)
+	state.Put("attachedIsoOnSata", true)
+	state.Put("vmName", "foo")
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test that ISO was removed
+	if len(driver.VBoxManageCalls) != 1 {
+		t.Fatalf("bad: %#v", driver.VBoxManageCalls)
+	}
+	if driver.VBoxManageCalls[0][3] != "SATA Controller" {
+		t.Fatalf("bad: %#v", driver.VBoxManageCalls)
+	}
+}
+
 func TestStepRemoveDevices_floppyPath(t *testing.T) {
 	state := testState(t)
 	step := new(StepRemoveDevices)
diff --git a/builder/virtualbox/iso/step_type_boot_command.go b/builder/virtualbox/common/step_type_boot_command.go
similarity index 92%
rename from builder/virtualbox/iso/step_type_boot_command.go
rename to builder/virtualbox/common/step_type_boot_command.go
index 3e087f0df..d22584951 100644
--- a/builder/virtualbox/iso/step_type_boot_command.go
+++ b/builder/virtualbox/common/step_type_boot_command.go
@@ -1,9 +1,8 @@
-package iso
+package common
 
 import (
 	"fmt"
 	"github.com/mitchellh/multistep"
-	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"strings"
@@ -23,7 +22,6 @@ type bootCommandTemplateData struct {
 // This step "types" the boot command into the VM over VNC.
 //
 // Uses:
-//   config *config
 //   driver Driver
 //   http_port int
 //   ui     packer.Ui
@@ -31,11 +29,14 @@ type bootCommandTemplateData struct {
 //
 // Produces:
 //   <nothing>
-type stepTypeBootCommand struct{}
+type StepTypeBootCommand struct {
+	BootCommand []string
+	VMName      string
+	Tpl         *packer.ConfigTemplate
+}
 
-func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vboxcommon.Driver)
+func (s *StepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
 	httpPort := state.Get("http_port").(uint)
 	ui := state.Get("ui").(packer.Ui)
 	vmName := state.Get("vmName").(string)
@@ -43,12 +44,12 @@ func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction
 	tplData := &bootCommandTemplateData{
 		"10.0.2.2",
 		httpPort,
-		config.VMName,
+		s.VMName,
 	}
 
 	ui.Say("Typing the boot command...")
-	for _, command := range config.BootCommand {
-		command, err := config.tpl.Process(command, tplData)
+	for _, command := range s.BootCommand {
+		command, err := s.Tpl.Process(command, tplData)
 		if err != nil {
 			err := fmt.Errorf("Error preparing boot command: %s", err)
 			state.Put("error", err)
@@ -90,7 +91,7 @@ func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction
 	return multistep.ActionContinue
 }
 
-func (*stepTypeBootCommand) Cleanup(multistep.StateBag) {}
+func (*StepTypeBootCommand) Cleanup(multistep.StateBag) {}
 
 func scancodes(message string) []string {
 	// Scancodes reference: http://www.win.tue.nl/~aeb/linux/kbd/scancodes-1.html
diff --git a/builder/virtualbox/iso/step_upload_guest_additions.go b/builder/virtualbox/common/step_upload_guest_additions.go
similarity index 72%
rename from builder/virtualbox/iso/step_upload_guest_additions.go
rename to builder/virtualbox/common/step_upload_guest_additions.go
index 0ae72c000..04d2dc7cc 100644
--- a/builder/virtualbox/iso/step_upload_guest_additions.go
+++ b/builder/virtualbox/common/step_upload_guest_additions.go
@@ -1,9 +1,8 @@
-package iso
+package common
 
 import (
 	"fmt"
 	"github.com/mitchellh/multistep"
-	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
@@ -14,16 +13,19 @@ type guestAdditionsPathTemplate struct {
 }
 
 // This step uploads the guest additions ISO to the VM.
-type stepUploadGuestAdditions struct{}
+type StepUploadGuestAdditions struct {
+	GuestAdditionsMode string
+	GuestAdditionsPath string
+	Tpl                *packer.ConfigTemplate
+}
 
-func (s *stepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
+func (s *StepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepAction {
 	comm := state.Get("communicator").(packer.Communicator)
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vboxcommon.Driver)
+	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
 
 	// If we're attaching then don't do this, since we attached.
-	if config.GuestAdditionsMode != GuestAdditionsModeUpload {
+	if s.GuestAdditionsMode != GuestAdditionsModeUpload {
 		log.Println("Not uploading guest additions since mode is not upload")
 		return multistep.ActionContinue
 	}
@@ -47,7 +49,7 @@ func (s *stepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepA
 		Version: version,
 	}
 
-	config.GuestAdditionsPath, err = config.tpl.Process(config.GuestAdditionsPath, tplData)
+	s.GuestAdditionsPath, err = s.Tpl.Process(s.GuestAdditionsPath, tplData)
 	if err != nil {
 		err := fmt.Errorf("Error preparing guest additions path: %s", err)
 		state.Put("error", err)
@@ -56,7 +58,7 @@ func (s *stepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepA
 	}
 
 	ui.Say("Uploading VirtualBox guest additions ISO...")
-	if err := comm.Upload(config.GuestAdditionsPath, f); err != nil {
+	if err := comm.Upload(s.GuestAdditionsPath, f, nil); err != nil {
 		state.Put("error", fmt.Errorf("Error uploading guest additions: %s", err))
 		return multistep.ActionHalt
 	}
@@ -64,4 +66,4 @@ func (s *stepUploadGuestAdditions) Run(state multistep.StateBag) multistep.StepA
 	return multistep.ActionContinue
 }
 
-func (s *stepUploadGuestAdditions) Cleanup(state multistep.StateBag) {}
+func (s *StepUploadGuestAdditions) Cleanup(state multistep.StateBag) {}
diff --git a/builder/virtualbox/common/step_upload_version.go b/builder/virtualbox/common/step_upload_version.go
index 1bfd526a6..02566c8cb 100644
--- a/builder/virtualbox/common/step_upload_version.go
+++ b/builder/virtualbox/common/step_upload_version.go
@@ -33,7 +33,7 @@ func (s *StepUploadVersion) Run(state multistep.StateBag) multistep.StepAction {
 	ui.Say(fmt.Sprintf("Uploading VirtualBox version info (%s)", version))
 	var data bytes.Buffer
 	data.WriteString(version)
-	if err := comm.Upload(s.Path, &data); err != nil {
+	if err := comm.Upload(s.Path, &data, nil); err != nil {
 		state.Put("error", fmt.Errorf("Error uploading VirtualBox version: %s", err))
 		return multistep.ActionHalt
 	}
diff --git a/builder/virtualbox/common/vboxmanage_post_config.go b/builder/virtualbox/common/vboxmanage_post_config.go
new file mode 100644
index 000000000..df683f100
--- /dev/null
+++ b/builder/virtualbox/common/vboxmanage_post_config.go
@@ -0,0 +1,28 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+)
+
+type VBoxManagePostConfig struct {
+	VBoxManagePost [][]string `mapstructure:"vboxmanage_post"`
+}
+
+func (c *VBoxManagePostConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.VBoxManagePost == nil {
+		c.VBoxManagePost = make([][]string, 0)
+	}
+
+	errs := make([]error, 0)
+	for i, args := range c.VBoxManagePost {
+		for j, arg := range args {
+			if err := t.Validate(arg); err != nil {
+				errs = append(errs,
+					fmt.Errorf("Error processing vboxmanage_post[%d][%d]: %s", i, j, err))
+			}
+		}
+	}
+
+	return errs
+}
diff --git a/builder/virtualbox/common/vboxmanage_post_config_test.go b/builder/virtualbox/common/vboxmanage_post_config_test.go
new file mode 100644
index 000000000..60a2c7abb
--- /dev/null
+++ b/builder/virtualbox/common/vboxmanage_post_config_test.go
@@ -0,0 +1,37 @@
+package common
+
+import (
+	"reflect"
+	"testing"
+)
+
+func TestVBoxManagePostConfigPrepare_VBoxManage(t *testing.T) {
+	// Test with empty
+	c := new(VBoxManagePostConfig)
+	errs := c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	if !reflect.DeepEqual(c.VBoxManagePost, [][]string{}) {
+		t.Fatalf("bad: %#v", c.VBoxManagePost)
+	}
+
+	// Test with a good one
+	c = new(VBoxManagePostConfig)
+	c.VBoxManagePost = [][]string{
+		{"foo", "bar", "baz"},
+	}
+	errs = c.Prepare(testConfigTemplate(t))
+	if len(errs) > 0 {
+		t.Fatalf("err: %#v", errs)
+	}
+
+	expected := [][]string{
+		[]string{"foo", "bar", "baz"},
+	}
+
+	if !reflect.DeepEqual(c.VBoxManagePost, expected) {
+		t.Fatalf("bad: %#v", c.VBoxManagePost)
+	}
+}
diff --git a/builder/virtualbox/iso/builder.go b/builder/virtualbox/iso/builder.go
index 7ec34bfe8..9b2b68031 100644
--- a/builder/virtualbox/iso/builder.go
+++ b/builder/virtualbox/iso/builder.go
@@ -3,40 +3,36 @@ package iso
 import (
 	"errors"
 	"fmt"
+	"log"
+	"math/rand"
+	"strings"
+	"time"
+
 	"github.com/mitchellh/multistep"
 	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
-	"log"
-	"strings"
 )
 
 const BuilderId = "mitchellh.virtualbox"
 
-// These are the different valid mode values for "guest_additions_mode" which
-// determine how guest additions are delivered to the guest.
-const (
-	GuestAdditionsModeDisable string = "disable"
-	GuestAdditionsModeAttach         = "attach"
-	GuestAdditionsModeUpload         = "upload"
-)
-
 type Builder struct {
 	config config
 	runner multistep.Runner
 }
 
 type config struct {
-	common.PackerConfig          `mapstructure:",squash"`
-	vboxcommon.ExportConfig      `mapstructure:",squash"`
-	vboxcommon.ExportOpts        `mapstructure:",squash"`
-	vboxcommon.FloppyConfig      `mapstructure:",squash"`
-	vboxcommon.OutputConfig      `mapstructure:",squash"`
-	vboxcommon.RunConfig         `mapstructure:",squash"`
-	vboxcommon.ShutdownConfig    `mapstructure:",squash"`
-	vboxcommon.SSHConfig         `mapstructure:",squash"`
-	vboxcommon.VBoxManageConfig  `mapstructure:",squash"`
-	vboxcommon.VBoxVersionConfig `mapstructure:",squash"`
+	common.PackerConfig             `mapstructure:",squash"`
+	vboxcommon.ExportConfig         `mapstructure:",squash"`
+	vboxcommon.ExportOpts           `mapstructure:",squash"`
+	vboxcommon.FloppyConfig         `mapstructure:",squash"`
+	vboxcommon.OutputConfig         `mapstructure:",squash"`
+	vboxcommon.RunConfig            `mapstructure:",squash"`
+	vboxcommon.ShutdownConfig       `mapstructure:",squash"`
+	vboxcommon.SSHConfig            `mapstructure:",squash"`
+	vboxcommon.VBoxManageConfig     `mapstructure:",squash"`
+	vboxcommon.VBoxManagePostConfig `mapstructure:",squash"`
+	vboxcommon.VBoxVersionConfig    `mapstructure:",squash"`
 
 	BootCommand          []string `mapstructure:"boot_command"`
 	DiskSize             uint     `mapstructure:"disk_size"`
@@ -46,11 +42,9 @@ type config struct {
 	GuestAdditionsSHA256 string   `mapstructure:"guest_additions_sha256"`
 	GuestOSType          string   `mapstructure:"guest_os_type"`
 	HardDriveInterface   string   `mapstructure:"hard_drive_interface"`
-	HTTPDir              string   `mapstructure:"http_directory"`
-	HTTPPortMin          uint     `mapstructure:"http_port_min"`
-	HTTPPortMax          uint     `mapstructure:"http_port_max"`
 	ISOChecksum          string   `mapstructure:"iso_checksum"`
 	ISOChecksumType      string   `mapstructure:"iso_checksum_type"`
+	ISOInterface         string   `mapstructure:"iso_interface"`
 	ISOUrls              []string `mapstructure:"iso_urls"`
 	VMName               string   `mapstructure:"vm_name"`
 
@@ -82,6 +76,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.SSHConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.VBoxManageConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.VBoxManagePostConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.VBoxVersionConfig.Prepare(b.config.tpl)...)
 	warnings := make([]string, 0)
 
@@ -105,16 +100,12 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.GuestOSType = "Other"
 	}
 
-	if b.config.HTTPPortMin == 0 {
-		b.config.HTTPPortMin = 8000
-	}
-
-	if b.config.HTTPPortMax == 0 {
-		b.config.HTTPPortMax = 9000
+	if b.config.ISOInterface == "" {
+		b.config.ISOInterface = "ide"
 	}
 
 	if b.config.VMName == "" {
-		b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName)
+		b.config.VMName = fmt.Sprintf("packer-%s-{{timestamp}}", b.config.PackerBuildName)
 	}
 
 	// Errors
@@ -123,9 +114,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		"guest_additions_sha256": &b.config.GuestAdditionsSHA256,
 		"guest_os_type":          &b.config.GuestOSType,
 		"hard_drive_interface":   &b.config.HardDriveInterface,
-		"http_directory":         &b.config.HTTPDir,
 		"iso_checksum":           &b.config.ISOChecksum,
 		"iso_checksum_type":      &b.config.ISOChecksumType,
+		"iso_interface":          &b.config.ISOInterface,
 		"iso_url":                &b.config.RawSingleISOUrl,
 		"vm_name":                &b.config.VMName,
 	}
@@ -172,11 +163,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 			errs, errors.New("hard_drive_interface can only be ide or sata"))
 	}
 
-	if b.config.HTTPPortMin > b.config.HTTPPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("http_port_min must be less than http_port_max"))
-	}
-
 	if b.config.ISOChecksumType == "" {
 		errs = packer.MultiErrorAppend(
 			errs, errors.New("The iso_checksum_type must be specified."))
@@ -198,6 +184,11 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
+	if b.config.ISOInterface != "ide" && b.config.ISOInterface != "sata" {
+		errs = packer.MultiErrorAppend(
+			errs, errors.New("iso_interface can only be ide or sata"))
+	}
+
 	if b.config.RawSingleISOUrl == "" && len(b.config.ISOUrls) == 0 {
 		errs = packer.MultiErrorAppend(
 			errs, errors.New("One of iso_url or iso_urls must be specified."))
@@ -218,9 +209,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	validMode := false
 	validModes := []string{
-		GuestAdditionsModeDisable,
-		GuestAdditionsModeAttach,
-		GuestAdditionsModeUpload,
+		vboxcommon.GuestAdditionsModeDisable,
+		vboxcommon.GuestAdditionsModeAttach,
+		vboxcommon.GuestAdditionsModeUpload,
 	}
 
 	for _, mode := range validModes {
@@ -260,6 +251,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 }
 
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	// Seed the random number generator
+	rand.Seed(time.Now().UTC().UnixNano())
+
 	// Create the driver that we'll use to communicate with VirtualBox
 	driver, err := vboxcommon.NewDriver()
 	if err != nil {
@@ -267,7 +261,12 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	}
 
 	steps := []multistep.Step{
-		new(stepDownloadGuestAdditions),
+		&vboxcommon.StepDownloadGuestAdditions{
+			GuestAdditionsMode:   b.config.GuestAdditionsMode,
+			GuestAdditionsURL:    b.config.GuestAdditionsURL,
+			GuestAdditionsSHA256: b.config.GuestAdditionsSHA256,
+			Tpl:                  b.config.tpl,
+		},
 		&common.StepDownload{
 			Checksum:     b.config.ISOChecksum,
 			ChecksumType: b.config.ISOChecksumType,
@@ -282,12 +281,18 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&common.StepCreateFloppy{
 			Files: b.config.FloppyFiles,
 		},
-		new(stepHTTPServer),
+		&vboxcommon.StepHTTPServer{
+			HTTPDir:     b.config.HTTPDir,
+			HTTPPortMin: b.config.HTTPPortMin,
+			HTTPPortMax: b.config.HTTPPortMax,
+		},
 		new(vboxcommon.StepSuppressMessages),
 		new(stepCreateVM),
 		new(stepCreateDisk),
 		new(stepAttachISO),
-		new(stepAttachGuestAdditions),
+		&vboxcommon.StepAttachGuestAdditions{
+			GuestAdditionsMode: b.config.GuestAdditionsMode,
+		},
 		new(vboxcommon.StepAttachFloppy),
 		&vboxcommon.StepForwardSSH{
 			GuestPort:      b.config.SSHPort,
@@ -303,7 +308,11 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			BootWait: b.config.BootWait,
 			Headless: b.config.Headless,
 		},
-		new(stepTypeBootCommand),
+		&vboxcommon.StepTypeBootCommand{
+			BootCommand: b.config.BootCommand,
+			VMName:      b.config.VMName,
+			Tpl:         b.config.tpl,
+		},
 		&common.StepConnectSSH{
 			SSHAddress:     vboxcommon.SSHAddress,
 			SSHConfig:      vboxcommon.SSHConfigFunc(b.config.SSHConfig),
@@ -312,13 +321,21 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&vboxcommon.StepUploadVersion{
 			Path: b.config.VBoxVersionFile,
 		},
-		new(stepUploadGuestAdditions),
+		&vboxcommon.StepUploadGuestAdditions{
+			GuestAdditionsMode: b.config.GuestAdditionsMode,
+			GuestAdditionsPath: b.config.GuestAdditionsPath,
+			Tpl:                b.config.tpl,
+		},
 		new(common.StepProvision),
 		&vboxcommon.StepShutdown{
 			Command: b.config.ShutdownCommand,
 			Timeout: b.config.ShutdownTimeout,
 		},
 		new(vboxcommon.StepRemoveDevices),
+		&vboxcommon.StepVBoxManage{
+			Commands: b.config.VBoxManagePost,
+			Tpl:      b.config.tpl,
+		},
 		&vboxcommon.StepExport{
 			Format:         b.config.Format,
 			OutputDir:      b.config.OutputDir,
diff --git a/builder/virtualbox/iso/builder_test.go b/builder/virtualbox/iso/builder_test.go
index ddd562f15..3b8e59569 100644
--- a/builder/virtualbox/iso/builder_test.go
+++ b/builder/virtualbox/iso/builder_test.go
@@ -1,6 +1,7 @@
 package iso
 
 import (
+	"github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/packer"
 	"reflect"
 	"testing"
@@ -37,7 +38,7 @@ func TestBuilderPrepare_Defaults(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.GuestAdditionsMode != GuestAdditionsModeUpload {
+	if b.config.GuestAdditionsMode != common.GuestAdditionsModeUpload {
 		t.Errorf("bad guest additions mode: %s", b.config.GuestAdditionsMode)
 	}
 
@@ -45,7 +46,7 @@ func TestBuilderPrepare_Defaults(t *testing.T) {
 		t.Errorf("bad guest OS type: %s", b.config.GuestOSType)
 	}
 
-	if b.config.VMName != "packer-foo" {
+	if b.config.VMName == "" {
 		t.Errorf("bad vm name: %s", b.config.VMName)
 	}
 
@@ -111,7 +112,7 @@ func TestBuilderPrepare_GuestAdditionsMode(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 
-	if b.config.GuestAdditionsMode != GuestAdditionsModeAttach {
+	if b.config.GuestAdditionsMode != common.GuestAdditionsModeAttach {
 		t.Fatalf("bad: %s", b.config.GuestAdditionsMode)
 	}
 
@@ -400,6 +401,47 @@ func TestBuilderPrepare_ISOChecksumType(t *testing.T) {
 	}
 }
 
+func TestBuilderPrepare_ISOInterface(t *testing.T) {
+	var b Builder
+	config := testConfig()
+
+	// Test a default boot_wait
+	delete(config, "iso_interface")
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if b.config.ISOInterface != "ide" {
+		t.Fatalf("bad: %s", b.config.ISOInterface)
+	}
+
+	// Test with a bad
+	config["iso_interface"] = "fake"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err == nil {
+		t.Fatal("should have error")
+	}
+
+	// Test with a good
+	config["iso_interface"] = "sata"
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+}
+
 func TestBuilderPrepare_ISOUrl(t *testing.T) {
 	var b Builder
 	config := testConfig()
diff --git a/builder/virtualbox/iso/step_attach_iso.go b/builder/virtualbox/iso/step_attach_iso.go
index f18281434..7fac2ec42 100644
--- a/builder/virtualbox/iso/step_attach_iso.go
+++ b/builder/virtualbox/iso/step_attach_iso.go
@@ -17,17 +17,27 @@ type stepAttachISO struct {
 }
 
 func (s *stepAttachISO) Run(state multistep.StateBag) multistep.StepAction {
+	config := state.Get("config").(*config)
 	driver := state.Get("driver").(vboxcommon.Driver)
 	isoPath := state.Get("iso_path").(string)
 	ui := state.Get("ui").(packer.Ui)
 	vmName := state.Get("vmName").(string)
 
+	controllerName := "IDE Controller"
+	port := "0"
+	device := "1"
+	if config.ISOInterface == "sata" {
+		controllerName = "SATA Controller"
+		port = "1"
+		device = "0"
+	}
+
 	// Attach the disk to the controller
 	command := []string{
 		"storageattach", vmName,
-		"--storagectl", "IDE Controller",
-		"--port", "0",
-		"--device", "1",
+		"--storagectl", controllerName,
+		"--port", port,
+		"--device", device,
 		"--type", "dvddrive",
 		"--medium", isoPath,
 	}
@@ -43,6 +53,9 @@ func (s *stepAttachISO) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Set some state so we know to remove
 	state.Put("attachedIso", true)
+	if controllerName == "SATA Controller" {
+		state.Put("attachedIsoOnSata", true)
+	}
 
 	return multistep.ActionContinue
 }
@@ -52,14 +65,24 @@ func (s *stepAttachISO) Cleanup(state multistep.StateBag) {
 		return
 	}
 
+	config := state.Get("config").(*config)
 	driver := state.Get("driver").(vboxcommon.Driver)
 	vmName := state.Get("vmName").(string)
 
+	controllerName := "IDE Controller"
+	port := "0"
+	device := "1"
+	if config.ISOInterface == "sata" {
+		controllerName = "SATA Controller"
+		port = "1"
+		device = "0"
+	}
+
 	command := []string{
 		"storageattach", vmName,
-		"--storagectl", "IDE Controller",
-		"--port", "0",
-		"--device", "1",
+		"--storagectl", controllerName,
+		"--port", port,
+		"--device", device,
 		"--medium", "none",
 	}
 
diff --git a/builder/virtualbox/iso/step_create_disk.go b/builder/virtualbox/iso/step_create_disk.go
index 6875d7b33..564a2f4d3 100644
--- a/builder/virtualbox/iso/step_create_disk.go
+++ b/builder/virtualbox/iso/step_create_disk.go
@@ -43,8 +43,7 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 	// Add the IDE controller so we can later attach the disk.
 	// When the hard disk controller is not IDE, this device is still used
 	// by VirtualBox to deliver the guest extensions.
-	controllerName := "IDE Controller"
-	err = driver.VBoxManage("storagectl", vmName, "--name", controllerName, "--add", "ide")
+	err = driver.VBoxManage("storagectl", vmName, "--name", "IDE Controller", "--add", "ide")
 	if err != nil {
 		err := fmt.Errorf("Error creating disk controller: %s", err)
 		state.Put("error", err)
@@ -55,9 +54,8 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 	// Add a SATA controller if we were asked to use SATA. We still attach
 	// the IDE controller above because some other things (disks) require
 	// that.
-	if config.HardDriveInterface == "sata" {
-		controllerName = "SATA Controller"
-		if err := driver.CreateSATAController(vmName, controllerName); err != nil {
+	if config.HardDriveInterface == "sata" || config.ISOInterface == "sata" {
+		if err := driver.CreateSATAController(vmName, "SATA Controller"); err != nil {
 			err := fmt.Errorf("Error creating disk controller: %s", err)
 			state.Put("error", err)
 			ui.Error(err.Error())
@@ -66,6 +64,11 @@ func (s *stepCreateDisk) Run(state multistep.StateBag) multistep.StepAction {
 	}
 
 	// Attach the disk to the controller
+	controllerName := "IDE Controller"
+	if config.HardDriveInterface == "sata" {
+		controllerName = "SATA Controller"
+	}
+
 	command = []string{
 		"storageattach", vmName,
 		"--storagectl", controllerName,
diff --git a/builder/virtualbox/iso/step_http_server.go b/builder/virtualbox/iso/step_http_server.go
index 24da8dd9d..3d86139e3 100644
--- a/builder/virtualbox/iso/step_http_server.go
+++ b/builder/virtualbox/iso/step_http_server.go
@@ -10,8 +10,9 @@ import (
 	"net/http"
 )
 
-// This step creates and runs the HTTP server that is serving the files
-// specified by the 'http_files` configuration parameter in the template.
+// This step creates and runs the HTTP server that is serving files from the
+// directory specified by the 'http_directory` configuration parameter in the
+// template.
 //
 // Uses:
 //   config *config
diff --git a/builder/virtualbox/ovf/builder.go b/builder/virtualbox/ovf/builder.go
index 65c4fe72a..6d031e19c 100644
--- a/builder/virtualbox/ovf/builder.go
+++ b/builder/virtualbox/ovf/builder.go
@@ -4,6 +4,8 @@ import (
 	"errors"
 	"fmt"
 	"log"
+	"math/rand"
+	"time"
 
 	"github.com/mitchellh/multistep"
 	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
@@ -32,6 +34,9 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 // Run executes a Packer build and returns a packer.Artifact representing
 // a VirtualBox appliance.
 func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packer.Artifact, error) {
+	// Seed the random number generator
+	rand.Seed(time.Now().UTC().UnixNano())
+
 	// Create the driver that we'll use to communicate with VirtualBox
 	driver, err := vboxcommon.NewDriver()
 	if err != nil {
@@ -42,6 +47,7 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	state := new(multistep.BasicStateBag)
 	state.Put("config", b.config)
 	state.Put("driver", driver)
+	state.Put("cache", cache)
 	state.Put("hook", hook)
 	state.Put("ui", ui)
 
@@ -55,14 +61,25 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&common.StepCreateFloppy{
 			Files: b.config.FloppyFiles,
 		},
-		&StepImport{
-			Name:       b.config.VMName,
-			SourcePath: b.config.SourcePath,
-			ImportOpts: b.config.ImportOpts,
+		&vboxcommon.StepHTTPServer{
+			HTTPDir:     b.config.HTTPDir,
+			HTTPPortMin: b.config.HTTPPortMin,
+			HTTPPortMax: b.config.HTTPPortMax,
+		},
+		&vboxcommon.StepDownloadGuestAdditions{
+			GuestAdditionsMode:   b.config.GuestAdditionsMode,
+			GuestAdditionsURL:    b.config.GuestAdditionsURL,
+			GuestAdditionsSHA256: b.config.GuestAdditionsSHA256,
+			Tpl:                  b.config.tpl,
+		},
+		&StepImport{
+			Name:        b.config.VMName,
+			SourcePath:  b.config.SourcePath,
+			ImportFlags: b.config.ImportFlags,
+		},
+		&vboxcommon.StepAttachGuestAdditions{
+			GuestAdditionsMode: b.config.GuestAdditionsMode,
 		},
-		/*
-			new(stepAttachGuestAdditions),
-		*/
 		new(vboxcommon.StepAttachFloppy),
 		&vboxcommon.StepForwardSSH{
 			GuestPort:      b.config.SSHPort,
@@ -78,6 +95,11 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			BootWait: b.config.BootWait,
 			Headless: b.config.Headless,
 		},
+		&vboxcommon.StepTypeBootCommand{
+			BootCommand: b.config.BootCommand,
+			VMName:      b.config.VMName,
+			Tpl:         b.config.tpl,
+		},
 		&common.StepConnectSSH{
 			SSHAddress:     vboxcommon.SSHAddress,
 			SSHConfig:      vboxcommon.SSHConfigFunc(b.config.SSHConfig),
@@ -86,15 +108,21 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&vboxcommon.StepUploadVersion{
 			Path: b.config.VBoxVersionFile,
 		},
-		/*
-			new(stepUploadGuestAdditions),
-		*/
+		&vboxcommon.StepUploadGuestAdditions{
+			GuestAdditionsMode: b.config.GuestAdditionsMode,
+			GuestAdditionsPath: b.config.GuestAdditionsPath,
+			Tpl:                b.config.tpl,
+		},
 		new(common.StepProvision),
 		&vboxcommon.StepShutdown{
 			Command: b.config.ShutdownCommand,
 			Timeout: b.config.ShutdownTimeout,
 		},
 		new(vboxcommon.StepRemoveDevices),
+		&vboxcommon.StepVBoxManage{
+			Commands: b.config.VBoxManagePost,
+			Tpl:      b.config.tpl,
+		},
 		&vboxcommon.StepExport{
 			Format:         b.config.Format,
 			OutputDir:      b.config.OutputDir,
diff --git a/builder/virtualbox/ovf/config.go b/builder/virtualbox/ovf/config.go
index 054d09e3a..885687b67 100644
--- a/builder/virtualbox/ovf/config.go
+++ b/builder/virtualbox/ovf/config.go
@@ -3,6 +3,7 @@ package ovf
 import (
 	"fmt"
 	"os"
+	"strings"
 
 	vboxcommon "github.com/mitchellh/packer/builder/virtualbox/common"
 	"github.com/mitchellh/packer/common"
@@ -11,20 +12,27 @@ import (
 
 // Config is the configuration structure for the builder.
 type Config struct {
-	common.PackerConfig          `mapstructure:",squash"`
-	vboxcommon.ExportConfig      `mapstructure:",squash"`
-	vboxcommon.ExportOpts        `mapstructure:",squash"`
-	vboxcommon.FloppyConfig      `mapstructure:",squash"`
-	vboxcommon.OutputConfig      `mapstructure:",squash"`
-	vboxcommon.RunConfig         `mapstructure:",squash"`
-	vboxcommon.SSHConfig         `mapstructure:",squash"`
-	vboxcommon.ShutdownConfig    `mapstructure:",squash"`
-	vboxcommon.VBoxManageConfig  `mapstructure:",squash"`
-	vboxcommon.VBoxVersionConfig `mapstructure:",squash"`
+	common.PackerConfig             `mapstructure:",squash"`
+	vboxcommon.ExportConfig         `mapstructure:",squash"`
+	vboxcommon.ExportOpts           `mapstructure:",squash"`
+	vboxcommon.FloppyConfig         `mapstructure:",squash"`
+	vboxcommon.OutputConfig         `mapstructure:",squash"`
+	vboxcommon.RunConfig            `mapstructure:",squash"`
+	vboxcommon.SSHConfig            `mapstructure:",squash"`
+	vboxcommon.ShutdownConfig       `mapstructure:",squash"`
+	vboxcommon.VBoxManageConfig     `mapstructure:",squash"`
+	vboxcommon.VBoxManagePostConfig `mapstructure:",squash"`
+	vboxcommon.VBoxVersionConfig    `mapstructure:",squash"`
 
-	SourcePath string `mapstructure:"source_path"`
-	VMName     string `mapstructure:"vm_name"`
-	ImportOpts string `mapstructure:"import_opts"`
+	BootCommand          []string `mapstructure:"boot_command"`
+	SourcePath           string   `mapstructure:"source_path"`
+	GuestAdditionsMode   string   `mapstructure:"guest_additions_mode"`
+	GuestAdditionsPath   string   `mapstructure:"guest_additions_path"`
+	GuestAdditionsURL    string   `mapstructure:"guest_additions_url"`
+	GuestAdditionsSHA256 string   `mapstructure:"guest_additions_sha256"`
+	VMName               string   `mapstructure:"vm_name"`
+	ImportOpts           string   `mapstructure:"import_opts"`
+	ImportFlags          []string `mapstructure:"import_flags"`
 
 	tpl *packer.ConfigTemplate
 }
@@ -43,6 +51,13 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	c.tpl.UserVars = c.PackerUserVars
 
 	// Defaults
+	if c.GuestAdditionsMode == "" {
+		c.GuestAdditionsMode = "upload"
+	}
+
+	if c.GuestAdditionsPath == "" {
+		c.GuestAdditionsPath = "VBoxGuestAdditions.iso"
+	}
 	if c.VMName == "" {
 		c.VMName = fmt.Sprintf("packer-%s-{{timestamp}}", c.PackerBuildName)
 	}
@@ -57,12 +72,15 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	errs = packer.MultiErrorAppend(errs, c.ShutdownConfig.Prepare(c.tpl)...)
 	errs = packer.MultiErrorAppend(errs, c.SSHConfig.Prepare(c.tpl)...)
 	errs = packer.MultiErrorAppend(errs, c.VBoxManageConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.VBoxManagePostConfig.Prepare(c.tpl)...)
 	errs = packer.MultiErrorAppend(errs, c.VBoxVersionConfig.Prepare(c.tpl)...)
 
 	templates := map[string]*string{
-		"source_path": &c.SourcePath,
-		"vm_name":     &c.VMName,
-		"import_opts": &c.ImportOpts,
+		"guest_additions_mode":   &c.GuestAdditionsMode,
+		"guest_additions_sha256": &c.GuestAdditionsSHA256,
+		"source_path":            &c.SourcePath,
+		"vm_name":                &c.VMName,
+		"import_opts":            &c.ImportOpts,
 	}
 
 	for n, ptr := range templates {
@@ -74,6 +92,21 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		}
 	}
 
+	sliceTemplates := map[string][]string{
+		"import_flags": c.ImportFlags,
+	}
+
+	for n, slice := range sliceTemplates {
+		for i, elem := range slice {
+			var err error
+			slice[i], err = c.tpl.Process(elem, nil)
+			if err != nil {
+				errs = packer.MultiErrorAppend(
+					errs, fmt.Errorf("Error processing %s[%d]: %s", n, i, err))
+			}
+		}
+	}
+
 	if c.SourcePath == "" {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("source_path is required"))
 	} else {
@@ -83,6 +116,48 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		}
 	}
 
+	for i, command := range c.BootCommand {
+		if err := c.tpl.Validate(command); err != nil {
+			errs = packer.MultiErrorAppend(errs,
+				fmt.Errorf("Error processing boot_command[%d]: %s", i, err))
+		}
+	}
+
+	validates := map[string]*string{
+		"guest_additions_path": &c.GuestAdditionsPath,
+		"guest_additions_url":  &c.GuestAdditionsURL,
+	}
+
+	for n, ptr := range validates {
+		if err := c.tpl.Validate(*ptr); err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error parsing %s: %s", n, err))
+		}
+	}
+
+	validMode := false
+	validModes := []string{
+		vboxcommon.GuestAdditionsModeDisable,
+		vboxcommon.GuestAdditionsModeAttach,
+		vboxcommon.GuestAdditionsModeUpload,
+	}
+
+	for _, mode := range validModes {
+		if c.GuestAdditionsMode == mode {
+			validMode = true
+			break
+		}
+	}
+
+	if !validMode {
+		errs = packer.MultiErrorAppend(errs,
+			fmt.Errorf("guest_additions_mode is invalid. Must be one of: %v", validModes))
+	}
+
+	if c.GuestAdditionsSHA256 != "" {
+		c.GuestAdditionsSHA256 = strings.ToLower(c.GuestAdditionsSHA256)
+	}
+
 	// Warnings
 	var warnings []string
 	if c.ShutdownCommand == "" {
@@ -96,5 +171,10 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		return nil, warnings, errs
 	}
 
+	// TODO: Write a packer fix and just remove import_opts
+	if c.ImportOpts != "" {
+		c.ImportFlags = append(c.ImportFlags, "--options", c.ImportOpts)
+	}
+
 	return c, warnings, nil
 }
diff --git a/builder/virtualbox/ovf/step_import.go b/builder/virtualbox/ovf/step_import.go
index 3dc72c174..b9a74c9f8 100644
--- a/builder/virtualbox/ovf/step_import.go
+++ b/builder/virtualbox/ovf/step_import.go
@@ -9,9 +9,9 @@ import (
 
 // This step imports an OVF VM into VirtualBox.
 type StepImport struct {
-	Name       string
-	SourcePath string
-	ImportOpts string
+	Name        string
+	SourcePath  string
+	ImportFlags []string
 
 	vmName string
 }
@@ -21,7 +21,7 @@ func (s *StepImport) Run(state multistep.StateBag) multistep.StepAction {
 	ui := state.Get("ui").(packer.Ui)
 
 	ui.Say(fmt.Sprintf("Importing VM: %s", s.SourcePath))
-	if err := driver.Import(s.Name, s.SourcePath, s.ImportOpts); err != nil {
+	if err := driver.Import(s.Name, s.SourcePath, s.ImportFlags); err != nil {
 		err := fmt.Errorf("Error importing VM: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
diff --git a/builder/vmware/common/artifact.go b/builder/vmware/common/artifact.go
index ddc2b1a35..710ed9aad 100644
--- a/builder/vmware/common/artifact.go
+++ b/builder/vmware/common/artifact.go
@@ -56,6 +56,10 @@ func (a *localArtifact) String() string {
 	return fmt.Sprintf("VM files in directory: %s", a.dir)
 }
 
+func (a *localArtifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *localArtifact) Destroy() error {
 	return os.RemoveAll(a.dir)
 }
diff --git a/builder/vmware/common/driver.go b/builder/vmware/common/driver.go
index 35a358cc4..c645f40b7 100644
--- a/builder/vmware/common/driver.go
+++ b/builder/vmware/common/driver.go
@@ -78,19 +78,7 @@ func NewDriver(dconfig *DriverConfig, config *SSHConfig) (Driver, error) {
 			},
 		}
 	case "linux":
-		drivers = []Driver{
-			&Workstation10Driver{
-				Workstation9Driver: Workstation9Driver{
-					SSHConfig: config,
-				},
-			},
-			&Workstation9Driver{
-				SSHConfig: config,
-			},
-			&Player5LinuxDriver{
-				SSHConfig: config,
-			},
-		}
+		fallthrough
 	case "windows":
 		drivers = []Driver{
 			&Workstation10Driver{
@@ -101,6 +89,14 @@ func NewDriver(dconfig *DriverConfig, config *SSHConfig) (Driver, error) {
 			&Workstation9Driver{
 				SSHConfig: config,
 			},
+			&Player6Driver{
+				Player5Driver: Player5Driver{
+					SSHConfig: config,
+				},
+			},
+			&Player5Driver{
+				SSHConfig: config,
+			},
 		}
 	default:
 		return nil, fmt.Errorf("can't find driver for OS: %s", runtime.GOOS)
@@ -133,7 +129,12 @@ func runAndLog(cmd *exec.Cmd) (string, string, error) {
 	stderrString := strings.TrimSpace(stderr.String())
 
 	if _, ok := err.(*exec.ExitError); ok {
-		err = fmt.Errorf("VMware error: %s", stderrString)
+		message := stderrString
+		if message == "" {
+			message = stdoutString
+		}
+
+		err = fmt.Errorf("VMware error: %s", message)
 	}
 
 	log.Printf("stdout: %s", stdoutString)
@@ -151,13 +152,13 @@ func normalizeVersion(version string) (string, error) {
 	i, err := strconv.Atoi(version)
 	if err != nil {
 		return "", fmt.Errorf(
-			"VMWare version '%s' is not numeric", version)
+			"VMware version '%s' is not numeric", version)
 	}
 
 	return fmt.Sprintf("%02d", i), nil
 }
 
-func compareVersions(versionFound string, versionWanted string) error {
+func compareVersions(versionFound string, versionWanted string, product string) error {
 	found, err := normalizeVersion(versionFound)
 	if err != nil {
 		return err
@@ -170,7 +171,7 @@ func compareVersions(versionFound string, versionWanted string) error {
 
 	if found < wanted {
 		return fmt.Errorf(
-			"VMWare WS version %s, or greater, is required. Found version: %s", versionWanted, versionFound)
+			"VMware %s version %s, or greater, is required. Found version: %s", product, versionWanted, versionFound)
 	}
 
 	return nil
diff --git a/builder/vmware/common/driver_config.go b/builder/vmware/common/driver_config.go
index d1288cf4c..c28e30de0 100644
--- a/builder/vmware/common/driver_config.go
+++ b/builder/vmware/common/driver_config.go
@@ -2,6 +2,7 @@ package common
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/mitchellh/packer/packer"
 )
@@ -11,6 +12,9 @@ type DriverConfig struct {
 }
 
 func (c *DriverConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.FusionAppPath == "" {
+		c.FusionAppPath = os.Getenv("FUSION_APP_PATH")
+	}
 	if c.FusionAppPath == "" {
 		c.FusionAppPath = "/Applications/VMware Fusion.app"
 	}
diff --git a/builder/vmware/common/driver_fusion5.go b/builder/vmware/common/driver_fusion5.go
index ee6cdd6c1..3a295e731 100644
--- a/builder/vmware/common/driver_fusion5.go
+++ b/builder/vmware/common/driver_fusion5.go
@@ -12,7 +12,7 @@ import (
 	"github.com/mitchellh/multistep"
 )
 
-// Fusion5Driver is a driver that can run VMWare Fusion 5.
+// Fusion5Driver is a driver that can run VMware Fusion 5.
 type Fusion5Driver struct {
 	// This is the path to the "VMware Fusion.app"
 	AppPath string
@@ -90,6 +90,12 @@ func (d *Fusion5Driver) Start(vmxPath string, headless bool) error {
 func (d *Fusion5Driver) Stop(vmxPath string) error {
 	cmd := exec.Command(d.vmrunPath(), "-T", "fusion", "stop", vmxPath, "hard")
 	if _, _, err := runAndLog(cmd); err != nil {
+		// Check if the VM is running. If its not, it was already stopped
+		running, rerr := d.IsRunning(vmxPath)
+		if rerr == nil && !running {
+			return nil
+		}
+
 		return err
 	}
 
diff --git a/builder/vmware/common/driver_fusion6.go b/builder/vmware/common/driver_fusion6.go
index 98c466cb9..af42c7ef9 100644
--- a/builder/vmware/common/driver_fusion6.go
+++ b/builder/vmware/common/driver_fusion6.go
@@ -11,7 +11,9 @@ import (
 	"strings"
 )
 
-// Fusion6Driver is a driver that can run VMWare Fusion 5.
+const VMWARE_FUSION_VERSION = "6"
+
+// Fusion6Driver is a driver that can run VMware Fusion 6.
 type Fusion6Driver struct {
 	Fusion5Driver
 }
@@ -22,6 +24,12 @@ func (d *Fusion6Driver) Clone(dst, src string) error {
 		"clone", src, dst,
 		"full")
 	if _, _, err := runAndLog(cmd); err != nil {
+		if strings.Contains(err.Error(), "parameters was invalid") {
+			return fmt.Errorf(
+				"Clone is not supported with your version of Fusion. Packer "+
+					"only works with Fusion %s Professional or above. Please verify your version.", VMWARE_FUSION_VERSION)
+		}
+
 		return err
 	}
 
@@ -50,7 +58,7 @@ func (d *Fusion6Driver) Verify() error {
 		return err
 	}
 
-	versionRe := regexp.MustCompile(`(?i)VMware [a-z0-9-]+ (\d+\.\d+\.\d+)\s`)
+	versionRe := regexp.MustCompile(`(?i)VMware [a-z0-9-]+ (\d+)\.`)
 	matches := versionRe.FindStringSubmatch(stderr.String())
 	if matches == nil {
 		return fmt.Errorf(
@@ -58,10 +66,5 @@ func (d *Fusion6Driver) Verify() error {
 	}
 	log.Printf("Detected VMware version: %s", matches[1])
 
-	if !strings.HasPrefix(matches[1], "6.") {
-		return fmt.Errorf(
-			"Fusion 6 not detected. Got version: %s", matches[1])
-	}
-
-	return nil
+	return compareVersions(matches[1], VMWARE_FUSION_VERSION, "Fusion Professional")
 }
diff --git a/builder/vmware/common/driver_player5.go b/builder/vmware/common/driver_player5.go
index 96c92e1e3..5bb80a0f2 100644
--- a/builder/vmware/common/driver_player5.go
+++ b/builder/vmware/common/driver_player5.go
@@ -3,6 +3,7 @@ package common
 import (
 	"errors"
 	"fmt"
+	"log"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -11,8 +12,8 @@ import (
 	"github.com/mitchellh/multistep"
 )
 
-// Player5LinuxDriver is a driver that can run VMware Player 5 on Linux.
-type Player5LinuxDriver struct {
+// Player5Driver is a driver that can run VMware Player 5 on Linux.
+type Player5Driver struct {
 	AppPath          string
 	VdiskManagerPath string
 	QemuImgPath      string
@@ -22,11 +23,11 @@ type Player5LinuxDriver struct {
 	SSHConfig *SSHConfig
 }
 
-func (d *Player5LinuxDriver) Clone(dst, src string) error {
-	return errors.New("Cloning is not supported with Player 5. Please use Player 6+.")
+func (d *Player5Driver) Clone(dst, src string) error {
+	return errors.New("Cloning is not supported with VMWare Player version 5. Please use VMWare Player version 6, or greater.")
 }
 
-func (d *Player5LinuxDriver) CompactDisk(diskPath string) error {
+func (d *Player5Driver) CompactDisk(diskPath string) error {
 	if d.QemuImgPath != "" {
 		return d.qemuCompactDisk(diskPath)
 	}
@@ -44,7 +45,7 @@ func (d *Player5LinuxDriver) CompactDisk(diskPath string) error {
 	return nil
 }
 
-func (d *Player5LinuxDriver) qemuCompactDisk(diskPath string) error {
+func (d *Player5Driver) qemuCompactDisk(diskPath string) error {
 	cmd := exec.Command(d.QemuImgPath, "convert", "-f", "vmdk", "-O", "vmdk", "-o", "compat6", diskPath, diskPath+".new")
 	if _, _, err := runAndLog(cmd); err != nil {
 		return err
@@ -61,7 +62,7 @@ func (d *Player5LinuxDriver) qemuCompactDisk(diskPath string) error {
 	return nil
 }
 
-func (d *Player5LinuxDriver) CreateDisk(output string, size string, type_id string) error {
+func (d *Player5Driver) CreateDisk(output string, size string, type_id string) error {
 	var cmd *exec.Cmd
 	if d.QemuImgPath != "" {
 		cmd = exec.Command(d.QemuImgPath, "create", "-f", "vmdk", "-o", "compat6", output, size)
@@ -75,7 +76,7 @@ func (d *Player5LinuxDriver) CreateDisk(output string, size string, type_id stri
 	return nil
 }
 
-func (d *Player5LinuxDriver) IsRunning(vmxPath string) (bool, error) {
+func (d *Player5Driver) IsRunning(vmxPath string) (bool, error) {
 	vmxPath, err := filepath.Abs(vmxPath)
 	if err != nil {
 		return false, err
@@ -96,11 +97,11 @@ func (d *Player5LinuxDriver) IsRunning(vmxPath string) (bool, error) {
 	return false, nil
 }
 
-func (d *Player5LinuxDriver) SSHAddress(state multistep.StateBag) (string, error) {
+func (d *Player5Driver) SSHAddress(state multistep.StateBag) (string, error) {
 	return SSHAddressFunc(d.SSHConfig)(state)
 }
 
-func (d *Player5LinuxDriver) Start(vmxPath string, headless bool) error {
+func (d *Player5Driver) Start(vmxPath string, headless bool) error {
 	guiArgument := "gui"
 	if headless {
 		guiArgument = "nogui"
@@ -114,7 +115,7 @@ func (d *Player5LinuxDriver) Start(vmxPath string, headless bool) error {
 	return nil
 }
 
-func (d *Player5LinuxDriver) Stop(vmxPath string) error {
+func (d *Player5Driver) Stop(vmxPath string) error {
 	cmd := exec.Command(d.VmrunPath, "-T", "player", "stop", vmxPath, "hard")
 	if _, _, err := runAndLog(cmd); err != nil {
 		return err
@@ -123,74 +124,78 @@ func (d *Player5LinuxDriver) Stop(vmxPath string) error {
 	return nil
 }
 
-func (d *Player5LinuxDriver) SuppressMessages(vmxPath string) error {
+func (d *Player5Driver) SuppressMessages(vmxPath string) error {
 	return nil
 }
 
-func (d *Player5LinuxDriver) Verify() error {
-	if err := d.findApp(); err != nil {
-		return fmt.Errorf("VMware Player application ('vmplayer') not found in path.")
-	}
-
-	if err := d.findVmrun(); err != nil {
-		return fmt.Errorf("Critical application 'vmrun' not found in path.")
-	}
-
-	if err := d.findVdiskManager(); err != nil {
-		if err := d.findQemuImg(); err != nil {
-			return fmt.Errorf(
-				"Neither 'vmware-vdiskmanager', nor 'qemu-img' found in path.\n" +
-					"One of these is required to configure disks for VMware Player.")
+func (d *Player5Driver) Verify() error {
+	var err error
+	if d.AppPath == "" {
+		if d.AppPath, err = playerFindVMware(); err != nil {
+			return err
 		}
 	}
 
-	return nil
-}
-
-func (d *Player5LinuxDriver) findApp() error {
-	path, err := exec.LookPath("vmplayer")
-	if err != nil {
-		return err
+	if d.VmrunPath == "" {
+		if d.VmrunPath, err = playerFindVmrun(); err != nil {
+			return err
+		}
 	}
-	d.AppPath = path
-	return nil
-}
 
-func (d *Player5LinuxDriver) findVdiskManager() error {
-	path, err := exec.LookPath("vmware-vdiskmanager")
-	if err != nil {
-		return err
+	if d.VdiskManagerPath == "" {
+		d.VdiskManagerPath, err = playerFindVdiskManager()
 	}
-	d.VdiskManagerPath = path
-	return nil
-}
 
-func (d *Player5LinuxDriver) findQemuImg() error {
-	path, err := exec.LookPath("qemu-img")
-	if err != nil {
-		return err
+	if d.VdiskManagerPath == "" && d.QemuImgPath == "" {
+		d.QemuImgPath, err = playerFindQemuImg()
 	}
-	d.QemuImgPath = path
-	return nil
-}
 
-func (d *Player5LinuxDriver) findVmrun() error {
-	path, err := exec.LookPath("vmrun")
 	if err != nil {
-		return err
+		return fmt.Errorf(
+			"Neither 'vmware-vdiskmanager', nor 'qemu-img' found in path.\n" +
+				"One of these is required to configure disks for VMware Player.")
 	}
-	d.VmrunPath = path
+
+	log.Printf("VMware app path: %s", d.AppPath)
+	log.Printf("vmrun path: %s", d.VmrunPath)
+	log.Printf("vdisk-manager path: %s", d.VdiskManagerPath)
+	log.Printf("qemu-img path: %s", d.QemuImgPath)
+
+	if _, err := os.Stat(d.AppPath); err != nil {
+		return fmt.Errorf("VMware application not found: %s", d.AppPath)
+	}
+
+	if _, err := os.Stat(d.VmrunPath); err != nil {
+		return fmt.Errorf("'vmrun' application not found: %s", d.VmrunPath)
+	}
+
+	if d.VdiskManagerPath != "" {
+		_, err = os.Stat(d.VdiskManagerPath)
+	} else {
+		_, err = os.Stat(d.QemuImgPath)
+	}
+
+	if err != nil {
+		return fmt.Errorf(
+			"Neither 'vmware-vdiskmanager', nor 'qemu-img' found in path.\n" +
+				"One of these is required to configure disks for VMware Player.")
+	}
+
 	return nil
 }
 
-func (d *Player5LinuxDriver) ToolsIsoPath(flavor string) string {
-	return "/usr/lib/vmware/isoimages/" + flavor + ".iso"
+func (d *Player5Driver) ToolsIsoPath(flavor string) string {
+	return playerToolsIsoPath(flavor)
 }
 
-func (d *Player5LinuxDriver) ToolsInstall() error {
+func (d *Player5Driver) ToolsInstall() error {
 	return nil
 }
 
-func (d *Player5LinuxDriver) DhcpLeasesPath(device string) string {
-	return "/etc/vmware/" + device + "/dhcpd/dhcpd.leases"
+func (d *Player5Driver) DhcpLeasesPath(device string) string {
+	return playerDhcpLeasesPath(device)
+}
+
+func (d *Player5Driver) VmnetnatConfPath() string {
+	return playerVmnetnatConfPath()
 }
diff --git a/builder/vmware/common/driver_player5_windows.go b/builder/vmware/common/driver_player5_windows.go
new file mode 100644
index 000000000..e16d275db
--- /dev/null
+++ b/builder/vmware/common/driver_player5_windows.go
@@ -0,0 +1,175 @@
+// +build windows
+
+package common
+
+import (
+	"log"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"syscall"
+)
+
+func playerFindVdiskManager() (string, error) {
+	path, err := exec.LookPath("vmware-vdiskmanager.exe")
+	if err == nil {
+		return path, nil
+	}
+
+	return findFile("vmware-vdiskmanager.exe", playerProgramFilePaths()), nil
+}
+
+func playerFindQemuImg() (string, error) {
+	path, err := exec.LookPath("qemu-img.exe")
+	if err == nil {
+		return path, nil
+	}
+
+	return findFile("qemu-img.exe", playerProgramFilePaths()), nil
+}
+
+func playerFindVMware() (string, error) {
+	path, err := exec.LookPath("vmplayer.exe")
+	if err == nil {
+		return path, nil
+	}
+
+	return findFile("vmplayer.exe", playerProgramFilePaths()), nil
+}
+
+func playerFindVmrun() (string, error) {
+	path, err := exec.LookPath("vmrun.exe")
+	if err == nil {
+		return path, nil
+	}
+
+	return findFile("vmrun.exe", playerProgramFilePaths()), nil
+}
+
+func playerToolsIsoPath(flavor string) string {
+	return findFile(flavor+".iso", playerProgramFilePaths())
+}
+
+func playerDhcpLeasesPath(device string) string {
+	path, err := playerDhcpLeasesPathRegistry()
+	if err != nil {
+		log.Printf("Error finding leases in registry: %s", err)
+	} else if _, err := os.Stat(path); err == nil {
+		return path
+	}
+
+	return findFile("vmnetdhcp.leases", playerDataFilePaths())
+}
+
+func playerVmnetnatConfPath() string {
+	return findFile("vmnetnat.conf", playerDataFilePaths())
+}
+
+// This reads the VMware installation path from the Windows registry.
+func playerVMwareRoot() (s string, err error) {
+	key := `SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\vmplayer.exe`
+	subkey := "Path"
+	s, err = readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
+	if err != nil {
+		log.Printf(`Unable to read registry key %s\%s`, key, subkey)
+		return
+	}
+
+	return normalizePath(s), nil
+}
+
+// This reads the VMware DHCP leases path from the Windows registry.
+func playerDhcpLeasesPathRegistry() (s string, err error) {
+	key := "SYSTEM\\CurrentControlSet\\services\\VMnetDHCP\\Parameters"
+	subkey := "LeaseFile"
+	s, err = readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
+	if err != nil {
+		log.Printf(`Unable to read registry key %s\%s`, key, subkey)
+		return
+	}
+
+	return normalizePath(s), nil
+}
+
+// playerProgramFilesPaths returns a list of paths that are eligible
+// to contain program files we may want just as vmware.exe.
+func playerProgramFilePaths() []string {
+	path, err := playerVMwareRoot()
+	if err != nil {
+		log.Printf("Error finding VMware root: %s", err)
+	}
+
+	paths := make([]string, 0, 5)
+	if os.Getenv("VMWARE_HOME") != "" {
+		paths = append(paths, os.Getenv("VMWARE_HOME"))
+	}
+
+	if path != "" {
+		paths = append(paths, path)
+	}
+
+	if os.Getenv("ProgramFiles(x86)") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("ProgramFiles(x86)"), "/VMware/VMware Player"))
+	}
+
+	if os.Getenv("ProgramFiles") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("ProgramFiles"), "/VMware/VMware Player"))
+	}
+
+	if os.Getenv("QEMU_HOME") != "" {
+		paths = append(paths, os.Getenv("QEMU_HOME"))
+	}
+
+	if os.Getenv("ProgramFiles(x86)") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("ProgramFiles(x86)"), "/QEMU"))
+	}
+
+	if os.Getenv("ProgramFiles") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("ProgramFiles"), "/QEMU"))
+	}
+
+	if os.Getenv("SystemDrive") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("SystemDrive"), "/QEMU"))
+	}
+
+	return paths
+}
+
+// playerDataFilePaths returns a list of paths that are eligible
+// to contain data files we may want such as vmnet NAT configuration files.
+func playerDataFilePaths() []string {
+	leasesPath, err := playerDhcpLeasesPathRegistry()
+	if err != nil {
+		log.Printf("Error getting DHCP leases path: %s", err)
+	}
+
+	if leasesPath != "" {
+		leasesPath = filepath.Dir(leasesPath)
+	}
+
+	paths := make([]string, 0, 5)
+	if os.Getenv("VMWARE_DATA") != "" {
+		paths = append(paths, os.Getenv("VMWARE_DATA"))
+	}
+
+	if leasesPath != "" {
+		paths = append(paths, leasesPath)
+	}
+
+	if os.Getenv("ProgramData") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("ProgramData"), "/VMware"))
+	}
+
+	if os.Getenv("ALLUSERSPROFILE") != "" {
+		paths = append(paths,
+			filepath.Join(os.Getenv("ALLUSERSPROFILE"), "/Application Data/VMware"))
+	}
+
+	return paths
+}
diff --git a/builder/vmware/common/driver_player6.go b/builder/vmware/common/driver_player6.go
new file mode 100644
index 000000000..d1cc7be88
--- /dev/null
+++ b/builder/vmware/common/driver_player6.go
@@ -0,0 +1,37 @@
+package common
+
+import (
+	"os/exec"
+)
+
+const VMWARE_PLAYER_VERSION = "6"
+
+// Player6Driver is a driver that can run VMware Player 6
+// installations.
+
+type Player6Driver struct {
+	Player5Driver
+}
+
+func (d *Player6Driver) Clone(dst, src string) error {
+	// TODO(rasa) check if running player+, not just player
+
+	cmd := exec.Command(d.Player5Driver.VmrunPath,
+		"-T", "ws",
+		"clone", src, dst,
+		"full")
+
+	if _, _, err := runAndLog(cmd); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (d *Player6Driver) Verify() error {
+	if err := d.Player5Driver.Verify(); err != nil {
+		return err
+	}
+
+	return playerVerifyVersion(VMWARE_PLAYER_VERSION)
+}
diff --git a/builder/vmware/common/driver_player6_windows.go b/builder/vmware/common/driver_player6_windows.go
new file mode 100644
index 000000000..91c1f7a19
--- /dev/null
+++ b/builder/vmware/common/driver_player6_windows.go
@@ -0,0 +1,35 @@
+// +build windows
+
+package common
+
+import (
+	"fmt"
+	"log"
+	"regexp"
+	"syscall"
+)
+
+func playerVerifyVersion(version string) error {
+	key := `SOFTWARE\Wow6432Node\VMware, Inc.\VMware Player`
+	subkey := "ProductVersion"
+	productVersion, err := readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
+	if err != nil {
+		log.Printf(`Unable to read registry key %s\%s`, key, subkey)
+		key = `SOFTWARE\VMware, Inc.\VMware Player`
+		productVersion, err = readRegString(syscall.HKEY_LOCAL_MACHINE, key, subkey)
+		if err != nil {
+			log.Printf(`Unable to read registry key %s\%s`, key, subkey)
+			return err
+		}
+	}
+
+	versionRe := regexp.MustCompile(`^(\d+)\.`)
+	matches := versionRe.FindStringSubmatch(productVersion)
+	if matches == nil {
+		return fmt.Errorf(
+			`Could not find a VMware Player version in registry key %s\%s: '%s'`, key, subkey, productVersion)
+	}
+	log.Printf("Detected VMware Player version: %s", matches[1])
+
+	return compareVersions(matches[1], version, "Player")
+}
diff --git a/builder/vmware/common/driver_player_unix.go b/builder/vmware/common/driver_player_unix.go
new file mode 100644
index 000000000..0c2cc8635
--- /dev/null
+++ b/builder/vmware/common/driver_player_unix.go
@@ -0,0 +1,68 @@
+// +build !windows
+
+// These functions are compatible with WS 9 and 10 on *NIX
+package common
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"os/exec"
+	"regexp"
+	"runtime"
+)
+
+func playerFindVdiskManager() (string, error) {
+	return exec.LookPath("vmware-vdiskmanager")
+}
+
+func playerFindQemuImg() (string, error) {
+	return exec.LookPath("qemu-img")
+}
+
+func playerFindVMware() (string, error) {
+	return exec.LookPath("vmplayer")
+}
+
+func playerFindVmrun() (string, error) {
+	return exec.LookPath("vmrun")
+}
+
+func playerDhcpLeasesPath(device string) string {
+	return "/etc/vmware/" + device + "/dhcpd/dhcpd.leases"
+}
+
+func playerToolsIsoPath(flavor string) string {
+	return "/usr/lib/vmware/isoimages/" + flavor + ".iso"
+}
+
+func playerVmnetnatConfPath() string {
+	return ""
+}
+
+func playerVerifyVersion(version string) error {
+	if runtime.GOOS != "linux" {
+		return fmt.Errorf("The VMWare Player version %s driver is only supported on Linux, and Windows, at the moment. Your OS: %s", version, runtime.GOOS)
+	}
+
+	//TODO(pmyjavec) there is a better way to find this, how?
+	//the default will suffice for now.
+	vmxpath := "/usr/lib/vmware/bin/vmware-vmx"
+
+	var stderr bytes.Buffer
+	cmd := exec.Command(vmxpath, "-v")
+	cmd.Stderr = &stderr
+	if err := cmd.Run(); err != nil {
+		return err
+	}
+
+	versionRe := regexp.MustCompile(`(?i)VMware Player (\d+)\.`)
+	matches := versionRe.FindStringSubmatch(stderr.String())
+	if matches == nil {
+		return fmt.Errorf(
+			"Could not find VMWare Player version in output: %s", stderr.String())
+	}
+	log.Printf("Detected VMWare Player version: %s", matches[1])
+
+	return compareVersions(matches[1], version, "Player")
+}
diff --git a/builder/vmware/common/driver_workstation10_windows.go b/builder/vmware/common/driver_workstation10_windows.go
index 11721e950..dd7028056 100644
--- a/builder/vmware/common/driver_workstation10_windows.go
+++ b/builder/vmware/common/driver_workstation10_windows.go
@@ -31,5 +31,5 @@ func workstationVerifyVersion(version string) error {
 	}
 	log.Printf("Detected VMware WS version: %s", matches[1])
 
-	return compareVersions(matches[1], version)
+	return compareVersions(matches[1], version, "Workstation")
 }
diff --git a/builder/vmware/common/driver_workstation9.go b/builder/vmware/common/driver_workstation9.go
index f4dff9d30..4c72c72b3 100644
--- a/builder/vmware/common/driver_workstation9.go
+++ b/builder/vmware/common/driver_workstation9.go
@@ -23,7 +23,7 @@ type Workstation9Driver struct {
 }
 
 func (d *Workstation9Driver) Clone(dst, src string) error {
-	return errors.New("Cloning is not supported with VMWare WS version 9. Please use VMWare WS version 10, or greater.")
+	return errors.New("Cloning is not supported with VMware WS version 9. Please use VMware WS version 10, or greater.")
 }
 
 func (d *Workstation9Driver) CompactDisk(diskPath string) error {
@@ -134,7 +134,7 @@ func (d *Workstation9Driver) Verify() error {
 	}
 
 	if _, err := os.Stat(d.VdiskManagerPath); err != nil {
-		return fmt.Errorf("'vmrun' application not found: %s", d.VdiskManagerPath)
+		return fmt.Errorf("'vmware-vdiskmanager' application not found: %s", d.VdiskManagerPath)
 	}
 
 	// Check to see if it APPEARS to be licensed.
diff --git a/builder/vmware/common/driver_workstation_unix.go b/builder/vmware/common/driver_workstation_unix.go
index 63b379e7c..bf6ef53da 100644
--- a/builder/vmware/common/driver_workstation_unix.go
+++ b/builder/vmware/common/driver_workstation_unix.go
@@ -53,7 +53,7 @@ func workstationVmnetnatConfPath() string {
 
 func workstationVerifyVersion(version string) error {
 	if runtime.GOOS != "linux" {
-		return fmt.Errorf("The VMWare WS version %s driver is only supported on Linux, and Windows, at the moment. Your OS: %s", version, runtime.GOOS)
+		return fmt.Errorf("The VMware WS version %s driver is only supported on Linux, and Windows, at the moment. Your OS: %s", version, runtime.GOOS)
 	}
 
 	//TODO(pmyjavec) there is a better way to find this, how?
@@ -71,9 +71,9 @@ func workstationVerifyVersion(version string) error {
 	matches := versionRe.FindStringSubmatch(stderr.String())
 	if matches == nil {
 		return fmt.Errorf(
-			"Could not find VMWare WS version in output: %s", stderr.String())
+			"Could not find VMware WS version in output: %s", stderr.String())
 	}
-	log.Printf("Detected VMWare WS version: %s", matches[1])
+	log.Printf("Detected VMware WS version: %s", matches[1])
 
-	return compareVersions(matches[1], version)
+	return compareVersions(matches[1], version, "Workstation")
 }
diff --git a/builder/vmware/iso/host_ip.go b/builder/vmware/common/host_ip.go
similarity index 91%
rename from builder/vmware/iso/host_ip.go
rename to builder/vmware/common/host_ip.go
index 98a6d26df..f920043e7 100644
--- a/builder/vmware/iso/host_ip.go
+++ b/builder/vmware/common/host_ip.go
@@ -1,4 +1,4 @@
-package iso
+package common
 
 // Interface to help find the host IP that is available from within
 // the VMware virtual machines.
diff --git a/builder/vmware/iso/host_ip_ifconfig.go b/builder/vmware/common/host_ip_ifconfig.go
similarity index 98%
rename from builder/vmware/iso/host_ip_ifconfig.go
rename to builder/vmware/common/host_ip_ifconfig.go
index 31243fafa..2a985aada 100644
--- a/builder/vmware/iso/host_ip_ifconfig.go
+++ b/builder/vmware/common/host_ip_ifconfig.go
@@ -1,4 +1,4 @@
-package iso
+package common
 
 import (
 	"bytes"
@@ -33,11 +33,10 @@ func (f *IfconfigIPFinder) HostIP() (string, error) {
 	stdout := new(bytes.Buffer)
 
 	cmd := exec.Command(ifconfigPath, f.Device)
-	cmd.Env = append(cmd.Env, os.Environ()...)
-
 	// Force LANG=C so that the output is what we expect it to be
 	// despite the locale.
 	cmd.Env = append(cmd.Env, "LANG=C")
+	cmd.Env = append(cmd.Env, os.Environ()...)
 
 	cmd.Stdout = stdout
 	cmd.Stderr = new(bytes.Buffer)
diff --git a/builder/vmware/common/host_ip_ifconfig_test.go b/builder/vmware/common/host_ip_ifconfig_test.go
new file mode 100644
index 000000000..a69104e69
--- /dev/null
+++ b/builder/vmware/common/host_ip_ifconfig_test.go
@@ -0,0 +1,11 @@
+package common
+
+import "testing"
+
+func TestIfconfigIPFinder_Impl(t *testing.T) {
+	var raw interface{}
+	raw = &IfconfigIPFinder{}
+	if _, ok := raw.(HostIPFinder); !ok {
+		t.Fatalf("IfconfigIPFinder is not a host IP finder")
+	}
+}
diff --git a/builder/vmware/iso/host_ip_vmnetnatconf.go b/builder/vmware/common/host_ip_vmnetnatconf.go
similarity index 90%
rename from builder/vmware/iso/host_ip_vmnetnatconf.go
rename to builder/vmware/common/host_ip_vmnetnatconf.go
index 0ba0a3727..e07227a5e 100644
--- a/builder/vmware/iso/host_ip_vmnetnatconf.go
+++ b/builder/vmware/common/host_ip_vmnetnatconf.go
@@ -1,4 +1,4 @@
-package iso
+package common
 
 import (
 	"bufio"
@@ -8,8 +8,6 @@ import (
 	"os"
 	"regexp"
 	"strings"
-
-	vmwcommon "github.com/mitchellh/packer/builder/vmware/common"
 )
 
 // VMnetNatConfIPFinder finds the IP address of the host machine by
@@ -18,7 +16,7 @@ import (
 type VMnetNatConfIPFinder struct{}
 
 func (*VMnetNatConfIPFinder) HostIP() (string, error) {
-	driver := &vmwcommon.Workstation9Driver{}
+	driver := &Workstation9Driver{}
 
 	vmnetnat := driver.VmnetnatConfPath()
 	if vmnetnat == "" {
diff --git a/builder/vmware/iso/host_ip_vmnetnatconf_test.go b/builder/vmware/common/host_ip_vmnetnatconf_test.go
similarity index 93%
rename from builder/vmware/iso/host_ip_vmnetnatconf_test.go
rename to builder/vmware/common/host_ip_vmnetnatconf_test.go
index 873a7fa2b..9f3114a92 100644
--- a/builder/vmware/iso/host_ip_vmnetnatconf_test.go
+++ b/builder/vmware/common/host_ip_vmnetnatconf_test.go
@@ -1,4 +1,4 @@
-package iso
+package common
 
 import "testing"
 
diff --git a/builder/vmware/common/run_config.go b/builder/vmware/common/run_config.go
index ce3480e9e..aef49683b 100644
--- a/builder/vmware/common/run_config.go
+++ b/builder/vmware/common/run_config.go
@@ -1,6 +1,7 @@
 package common
 
 import (
+	"errors"
 	"fmt"
 	"time"
 
@@ -11,6 +12,13 @@ type RunConfig struct {
 	Headless    bool   `mapstructure:"headless"`
 	RawBootWait string `mapstructure:"boot_wait"`
 
+	HTTPDir     string `mapstructure:"http_directory"`
+	HTTPPortMin uint   `mapstructure:"http_port_min"`
+	HTTPPortMax uint   `mapstructure:"http_port_max"`
+
+	VNCPortMin uint `mapstructure:"vnc_port_min"`
+	VNCPortMax uint `mapstructure:"vnc_port_max"`
+
 	BootWait time.Duration ``
 }
 
@@ -19,8 +27,25 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		c.RawBootWait = "10s"
 	}
 
+	if c.HTTPPortMin == 0 {
+		c.HTTPPortMin = 8000
+	}
+
+	if c.HTTPPortMax == 0 {
+		c.HTTPPortMax = 9000
+	}
+
+	if c.VNCPortMin == 0 {
+		c.VNCPortMin = 5900
+	}
+
+	if c.VNCPortMax == 0 {
+		c.VNCPortMax = 6000
+	}
+
 	templates := map[string]*string{
-		"boot_wait": &c.RawBootWait,
+		"boot_wait":      &c.RawBootWait,
+		"http_directory": &c.HTTPDir,
 	}
 
 	var err error
@@ -40,5 +65,15 @@ func (c *RunConfig) Prepare(t *packer.ConfigTemplate) []error {
 		}
 	}
 
+	if c.HTTPPortMin > c.HTTPPortMax {
+		errs = append(errs,
+			errors.New("http_port_min must be less than http_port_max"))
+	}
+
+	if c.VNCPortMin > c.VNCPortMax {
+		errs = append(
+			errs, fmt.Errorf("vnc_port_min must be less than vnc_port_max"))
+	}
+
 	return errs
 }
diff --git a/builder/vmware/common/ssh.go b/builder/vmware/common/ssh.go
index a931dd734..5d2ca40e2 100644
--- a/builder/vmware/common/ssh.go
+++ b/builder/vmware/common/ssh.go
@@ -1,14 +1,15 @@
 package common
 
 import (
-	gossh "code.google.com/p/go.crypto/ssh"
 	"errors"
 	"fmt"
 	"io/ioutil"
 	"log"
 	"os"
 
+	gossh "code.google.com/p/go.crypto/ssh"
 	"github.com/mitchellh/multistep"
+	commonssh "github.com/mitchellh/packer/common/ssh"
 	"github.com/mitchellh/packer/communicator/ssh"
 )
 
@@ -74,7 +75,7 @@ func SSHConfigFunc(config *SSHConfig) func(multistep.StateBag) (*gossh.ClientCon
 		}
 
 		if config.SSHKeyPath != "" {
-			signer, err := sshKeyToSigner(config.SSHKeyPath)
+			signer, err := commonssh.FileSigner(config.SSHKeyPath)
 			if err != nil {
 				return nil, err
 			}
@@ -88,23 +89,3 @@ func SSHConfigFunc(config *SSHConfig) func(multistep.StateBag) (*gossh.ClientCon
 		}, nil
 	}
 }
-
-func sshKeyToSigner(path string) (gossh.Signer, error) {
-	f, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	keyBytes, err := ioutil.ReadAll(f)
-	if err != nil {
-		return nil, err
-	}
-
-	signer, err := gossh.ParsePrivateKey(keyBytes)
-	if err != nil {
-		return nil, fmt.Errorf("Error setting up SSH config: %s", err)
-	}
-
-	return signer, nil
-}
diff --git a/builder/vmware/common/ssh_config.go b/builder/vmware/common/ssh_config.go
index 8bb616c17..75d0a4b75 100644
--- a/builder/vmware/common/ssh_config.go
+++ b/builder/vmware/common/ssh_config.go
@@ -7,6 +7,7 @@ import (
 	"os"
 	"time"
 
+	commonssh "github.com/mitchellh/packer/common/ssh"
 	"github.com/mitchellh/packer/packer"
 )
 
@@ -32,6 +33,7 @@ func (c *SSHConfig) Prepare(t *packer.ConfigTemplate) []error {
 	}
 
 	templates := map[string]*string{
+		"ssh_host":         &c.SSHHost,
 		"ssh_key_path":     &c.SSHKeyPath,
 		"ssh_password":     &c.SSHPassword,
 		"ssh_username":     &c.SSHUser,
@@ -50,7 +52,7 @@ func (c *SSHConfig) Prepare(t *packer.ConfigTemplate) []error {
 	if c.SSHKeyPath != "" {
 		if _, err := os.Stat(c.SSHKeyPath); err != nil {
 			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
-		} else if _, err := sshKeyToSigner(c.SSHKeyPath); err != nil {
+		} else if _, err := commonssh.FileSigner(c.SSHKeyPath); err != nil {
 			errs = append(errs, fmt.Errorf("ssh_key_path is invalid: %s", err))
 		}
 	}
diff --git a/builder/vmware/common/step_clean_vmx.go b/builder/vmware/common/step_clean_vmx.go
index b55bcd549..df7b42763 100644
--- a/builder/vmware/common/step_clean_vmx.go
+++ b/builder/vmware/common/step_clean_vmx.go
@@ -32,38 +32,27 @@ func (s StepCleanVMX) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
-	if _, ok := state.GetOk("floppy_path"); ok {
-		// Delete the floppy0 entries so the floppy is no longer mounted
-		ui.Message("Unmounting floppy from VMX...")
-		for k, _ := range vmxData {
-			if strings.HasPrefix(k, "floppy0.") {
-				log.Printf("Deleting key: %s", k)
-				delete(vmxData, k)
-			}
+	// Delete the floppy0 entries so the floppy is no longer mounted
+	ui.Message("Unmounting floppy from VMX...")
+	for k, _ := range vmxData {
+		if strings.HasPrefix(k, "floppy0.") {
+			log.Printf("Deleting key: %s", k)
+			delete(vmxData, k)
 		}
-		vmxData["floppy0.present"] = "FALSE"
 	}
+	vmxData["floppy0.present"] = "FALSE"
 
-	if isoPathRaw, ok := state.GetOk("iso_path"); ok {
-		isoPath := isoPathRaw.(string)
+	devRe := regexp.MustCompile(`^ide\d:\d\.`)
+	for k, v := range vmxData {
+		ide := devRe.FindString(k)
+		if ide == "" || v != "cdrom-image" {
+			continue
+		}
 
 		ui.Message("Detaching ISO from CD-ROM device...")
-		devRe := regexp.MustCompile(`^ide\d:\d\.`)
-		for k, _ := range vmxData {
-			match := devRe.FindString(k)
-			if match == "" {
-				continue
-			}
 
-			filenameKey := match + "filename"
-			if filename, ok := vmxData[filenameKey]; ok {
-				if filename == isoPath {
-					// Change the CD-ROM device back to auto-detect to eject
-					vmxData[filenameKey] = "auto detect"
-					vmxData[match+"devicetype"] = "cdrom-raw"
-				}
-			}
-		}
+		vmxData[ide+"devicetype"] = "cdrom-raw"
+		vmxData[ide+"filename"] = "auto detect"
 	}
 
 	// Rewrite the VMX
diff --git a/builder/vmware/common/step_clean_vmx_test.go b/builder/vmware/common/step_clean_vmx_test.go
index 59877027a..ea30fb54a 100644
--- a/builder/vmware/common/step_clean_vmx_test.go
+++ b/builder/vmware/common/step_clean_vmx_test.go
@@ -39,7 +39,6 @@ func TestStepCleanVMX_floppyPath(t *testing.T) {
 		t.Fatalf("err: %s", err)
 	}
 
-	state.Put("floppy_path", "foo")
 	state.Put("vmx_path", vmxPath)
 
 	// Test the run
@@ -89,7 +88,6 @@ func TestStepCleanVMX_isoPath(t *testing.T) {
 		t.Fatalf("err: %s", err)
 	}
 
-	state.Put("iso_path", "foo")
 	state.Put("vmx_path", vmxPath)
 
 	// Test the run
@@ -136,6 +134,7 @@ floppy0.filetype = "file"
 `
 
 const testVMXISOPath = `
+ide0:0.devicetype = "cdrom-image"
 ide0:0.filename = "foo"
 ide0:1.filename = "bar"
 foo = "bar"
diff --git a/builder/vmware/common/step_configure_vmx.go b/builder/vmware/common/step_configure_vmx.go
index 0d53c44e9..401d53055 100644
--- a/builder/vmware/common/step_configure_vmx.go
+++ b/builder/vmware/common/step_configure_vmx.go
@@ -18,6 +18,7 @@ import (
 //   vmx_path string
 type StepConfigureVMX struct {
 	CustomData map[string]string
+	SkipFloppy bool
 }
 
 func (s *StepConfigureVMX) Run(state multistep.StateBag) multistep.StepAction {
@@ -56,12 +57,15 @@ func (s *StepConfigureVMX) Run(state multistep.StateBag) multistep.StepAction {
 		vmxData[k] = v
 	}
 
-	// Set a floppy disk if we have one
-	if floppyPathRaw, ok := state.GetOk("floppy_path"); ok {
-		log.Println("Floppy path present, setting in VMX")
-		vmxData["floppy0.present"] = "TRUE"
-		vmxData["floppy0.filetype"] = "file"
-		vmxData["floppy0.filename"] = floppyPathRaw.(string)
+	// Set a floppy disk, but only if we should
+	if !s.SkipFloppy {
+		// Set a floppy disk if we have one
+		if floppyPathRaw, ok := state.GetOk("floppy_path"); ok {
+			log.Println("Floppy path present, setting in VMX")
+			vmxData["floppy0.present"] = "TRUE"
+			vmxData["floppy0.filetype"] = "file"
+			vmxData["floppy0.filename"] = floppyPathRaw.(string)
+		}
 	}
 
 	if err := WriteVMX(vmxPath, vmxData); err != nil {
diff --git a/builder/vmware/iso/step_configure_vnc.go b/builder/vmware/common/step_configure_vnc.go
similarity index 65%
rename from builder/vmware/iso/step_configure_vnc.go
rename to builder/vmware/common/step_configure_vnc.go
index 1f194be76..8ed6326aa 100644
--- a/builder/vmware/iso/step_configure_vnc.go
+++ b/builder/vmware/common/step_configure_vnc.go
@@ -1,40 +1,47 @@
-package iso
+package common
 
 import (
 	"fmt"
-	"github.com/mitchellh/multistep"
-	vmwcommon "github.com/mitchellh/packer/builder/vmware/common"
-	"github.com/mitchellh/packer/packer"
 	"io/ioutil"
 	"log"
 	"math/rand"
 	"net"
 	"os"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // This step configures the VM to enable the VNC server.
 //
 // Uses:
-//   config *config
 //   ui     packer.Ui
 //   vmx_path string
 //
 // Produces:
 //   vnc_port uint - The port that VNC is configured to listen on.
-type stepConfigureVNC struct{}
-
-type VNCAddressFinder interface {
-	VNCAddress(uint, uint) (string, uint)
+type StepConfigureVNC struct {
+	VNCPortMin uint
+	VNCPortMax uint
 }
 
-func (stepConfigureVNC) VNCAddress(portMin, portMax uint) (string, uint) {
+type VNCAddressFinder interface {
+	VNCAddress(uint, uint) (string, uint, error)
+}
+
+func (StepConfigureVNC) VNCAddress(portMin, portMax uint) (string, uint, error) {
 	// Find an open VNC port. Note that this can still fail later on
 	// because we have to release the port at some point. But this does its
 	// best.
 	var vncPort uint
 	portRange := int(portMax - portMin)
 	for {
-		vncPort = uint(rand.Intn(portRange)) + portMin
+		if portRange > 0 {
+			vncPort = uint(rand.Intn(portRange)) + portMin
+		} else {
+			vncPort = portMin
+		}
+
 		log.Printf("Trying port: %d", vncPort)
 		l, err := net.Listen("tcp", fmt.Sprintf(":%d", vncPort))
 		if err == nil {
@@ -42,12 +49,11 @@ func (stepConfigureVNC) VNCAddress(portMin, portMax uint) (string, uint) {
 			break
 		}
 	}
-	return "127.0.0.1", vncPort
+	return "127.0.0.1", vncPort, nil
 }
 
-func (s *stepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vmwcommon.Driver)
+func (s *StepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
 	ui := state.Get("ui").(packer.Ui)
 	vmxPath := state.Get("vmx_path").(string)
 
@@ -73,11 +79,9 @@ func (s *stepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction {
 	} else {
 		vncFinder = s
 	}
-	log.Printf("Looking for available port between %d and %d", config.VNCPortMin, config.VNCPortMax)
-	vncIp, vncPort := vncFinder.VNCAddress(config.VNCPortMin, config.VNCPortMax)
-	if vncPort == 0 {
-		err := fmt.Errorf("Unable to find available VNC port between %d and %d",
-			config.VNCPortMin, config.VNCPortMax)
+	log.Printf("Looking for available port between %d and %d", s.VNCPortMin, s.VNCPortMax)
+	vncIp, vncPort, err := vncFinder.VNCAddress(s.VNCPortMin, s.VNCPortMax)
+	if err != nil {
 		state.Put("error", err)
 		ui.Error(err.Error())
 		return multistep.ActionHalt
@@ -85,11 +89,11 @@ func (s *stepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction {
 
 	log.Printf("Found available VNC port: %d", vncPort)
 
-	vmxData := vmwcommon.ParseVMX(string(vmxBytes))
+	vmxData := ParseVMX(string(vmxBytes))
 	vmxData["remotedisplay.vnc.enabled"] = "TRUE"
 	vmxData["remotedisplay.vnc.port"] = fmt.Sprintf("%d", vncPort)
 
-	if err := vmwcommon.WriteVMX(vmxPath, vmxData); err != nil {
+	if err := WriteVMX(vmxPath, vmxData); err != nil {
 		err := fmt.Errorf("Error writing VMX data: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
@@ -102,5 +106,5 @@ func (s *stepConfigureVNC) Run(state multistep.StateBag) multistep.StepAction {
 	return multistep.ActionContinue
 }
 
-func (stepConfigureVNC) Cleanup(multistep.StateBag) {
+func (StepConfigureVNC) Cleanup(multistep.StateBag) {
 }
diff --git a/builder/vmware/common/step_http_server.go b/builder/vmware/common/step_http_server.go
new file mode 100644
index 000000000..440d9adbc
--- /dev/null
+++ b/builder/vmware/common/step_http_server.go
@@ -0,0 +1,78 @@
+package common
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"math/rand"
+	"net"
+	"net/http"
+)
+
+// This step creates and runs the HTTP server that is serving files from the
+// directory specified by the 'http_directory` configuration parameter in the
+// template.
+//
+// Uses:
+//   ui     packer.Ui
+//
+// Produces:
+//   http_port int - The port the HTTP server started on.
+type StepHTTPServer struct {
+	HTTPDir     string
+	HTTPPortMin uint
+	HTTPPortMax uint
+
+	l net.Listener
+}
+
+func (s *StepHTTPServer) Run(state multistep.StateBag) multistep.StepAction {
+	ui := state.Get("ui").(packer.Ui)
+
+	var httpPort uint = 0
+	if s.HTTPDir == "" {
+		state.Put("http_port", httpPort)
+		return multistep.ActionContinue
+	}
+
+	// Find an available TCP port for our HTTP server
+	var httpAddr string
+	portRange := int(s.HTTPPortMax - s.HTTPPortMin)
+	for {
+		var err error
+		var offset uint = 0
+
+		if portRange > 0 {
+			// Intn will panic if portRange == 0, so we do a check.
+			offset = uint(rand.Intn(portRange))
+		}
+
+		httpPort = offset + s.HTTPPortMin
+		httpAddr = fmt.Sprintf(":%d", httpPort)
+		log.Printf("Trying port: %d", httpPort)
+		s.l, err = net.Listen("tcp", httpAddr)
+		if err == nil {
+			break
+		}
+	}
+
+	ui.Say(fmt.Sprintf("Starting HTTP server on port %d", httpPort))
+
+	// Start the HTTP server and run it in the background
+	fileServer := http.FileServer(http.Dir(s.HTTPDir))
+	server := &http.Server{Addr: httpAddr, Handler: fileServer}
+	go server.Serve(s.l)
+
+	// Save the address into the state so it can be accessed in the future
+	state.Put("http_port", httpPort)
+
+	return multistep.ActionContinue
+}
+
+func (s *StepHTTPServer) Cleanup(multistep.StateBag) {
+	if s.l != nil {
+		// Close the listener so that the HTTP server stops
+		s.l.Close()
+	}
+}
diff --git a/builder/vmware/iso/step_prepare_tools.go b/builder/vmware/common/step_prepare_tools.go
similarity index 52%
rename from builder/vmware/iso/step_prepare_tools.go
rename to builder/vmware/common/step_prepare_tools.go
index d9ad4acce..f0566d91e 100644
--- a/builder/vmware/iso/step_prepare_tools.go
+++ b/builder/vmware/common/step_prepare_tools.go
@@ -1,33 +1,35 @@
-package iso
+package common
 
 import (
 	"fmt"
-	"github.com/mitchellh/multistep"
-	vmwcommon "github.com/mitchellh/packer/builder/vmware/common"
 	"os"
+
+	"github.com/mitchellh/multistep"
 )
 
-type stepPrepareTools struct{}
+type StepPrepareTools struct {
+	RemoteType        string
+	ToolsUploadFlavor string
+}
 
-func (*stepPrepareTools) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vmwcommon.Driver)
+func (c *StepPrepareTools) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
 
-	if config.RemoteType == "esx5" {
+	if c.RemoteType == "esx5" {
 		return multistep.ActionContinue
 	}
 
-	if config.ToolsUploadFlavor == "" {
+	if c.ToolsUploadFlavor == "" {
 		return multistep.ActionContinue
 	}
 
-	path := driver.ToolsIsoPath(config.ToolsUploadFlavor)
+	path := driver.ToolsIsoPath(c.ToolsUploadFlavor)
 	if _, err := os.Stat(path); err != nil {
 		state.Put("error", fmt.Errorf(
 			"Couldn't find VMware tools for '%s'! VMware often downloads these\n"+
 				"tools on-demand. However, to do this, you need to create a fake VM\n"+
 				"of the proper type then click the 'install tools' option in the\n"+
-				"VMware GUI.", config.ToolsUploadFlavor))
+				"VMware GUI.", c.ToolsUploadFlavor))
 		return multistep.ActionHalt
 	}
 
@@ -35,4 +37,4 @@ func (*stepPrepareTools) Run(state multistep.StateBag) multistep.StepAction {
 	return multistep.ActionContinue
 }
 
-func (*stepPrepareTools) Cleanup(multistep.StateBag) {}
+func (c *StepPrepareTools) Cleanup(multistep.StateBag) {}
diff --git a/builder/vmware/common/step_prepare_tools_test.go b/builder/vmware/common/step_prepare_tools_test.go
new file mode 100644
index 000000000..0326ea0d2
--- /dev/null
+++ b/builder/vmware/common/step_prepare_tools_test.go
@@ -0,0 +1,115 @@
+package common
+
+import (
+	"io/ioutil"
+	"os"
+	"testing"
+
+	"github.com/mitchellh/multistep"
+)
+
+func TestStepPrepareTools_impl(t *testing.T) {
+	var _ multistep.Step = new(StepPrepareTools)
+}
+
+func TestStepPrepareTools(t *testing.T) {
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	tf.Close()
+	defer os.Remove(tf.Name())
+
+	state := testState(t)
+	step := &StepPrepareTools{
+		RemoteType:        "",
+		ToolsUploadFlavor: "foo",
+	}
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Mock results
+	driver.ToolsIsoPathResult = tf.Name()
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test the driver
+	if !driver.ToolsIsoPathCalled {
+		t.Fatal("tools iso path should be called")
+	}
+	if driver.ToolsIsoPathFlavor != "foo" {
+		t.Fatalf("bad: %#v", driver.ToolsIsoPathFlavor)
+	}
+
+	// Test the resulting state
+	path, ok := state.GetOk("tools_upload_source")
+	if !ok {
+		t.Fatal("should have tools_upload_source")
+	}
+	if path != tf.Name() {
+		t.Fatalf("bad: %#v", path)
+	}
+}
+
+func TestStepPrepareTools_esx5(t *testing.T) {
+	state := testState(t)
+	step := &StepPrepareTools{
+		RemoteType:        "esx5",
+		ToolsUploadFlavor: "foo",
+	}
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionContinue {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); ok {
+		t.Fatal("should NOT have error")
+	}
+
+	// Test the driver
+	if driver.ToolsIsoPathCalled {
+		t.Fatal("tools iso path should NOT be called")
+	}
+}
+
+func TestStepPrepareTools_nonExist(t *testing.T) {
+	state := testState(t)
+	step := &StepPrepareTools{
+		RemoteType:        "",
+		ToolsUploadFlavor: "foo",
+	}
+
+	driver := state.Get("driver").(*DriverMock)
+
+	// Mock results
+	driver.ToolsIsoPathResult = "foo"
+
+	// Test the run
+	if action := step.Run(state); action != multistep.ActionHalt {
+		t.Fatalf("bad action: %#v", action)
+	}
+	if _, ok := state.GetOk("error"); !ok {
+		t.Fatal("should have error")
+	}
+
+	// Test the driver
+	if !driver.ToolsIsoPathCalled {
+		t.Fatal("tools iso path should be called")
+	}
+	if driver.ToolsIsoPathFlavor != "foo" {
+		t.Fatalf("bad: %#v", driver.ToolsIsoPathFlavor)
+	}
+
+	// Test the resulting state
+	if _, ok := state.GetOk("tools_upload_source"); ok {
+		t.Fatal("should NOT have tools_upload_source")
+	}
+}
diff --git a/builder/vmware/common/step_shutdown.go b/builder/vmware/common/step_shutdown.go
index 378d699b1..5aad45fd0 100644
--- a/builder/vmware/common/step_shutdown.go
+++ b/builder/vmware/common/step_shutdown.go
@@ -102,7 +102,7 @@ func (s *StepShutdown) Run(state multistep.StateBag) multistep.StepAction {
 
 	ui.Message("Waiting for VMware to clean up after itself...")
 	lockRegex := regexp.MustCompile(`(?i)\.lck$`)
-	timer := time.After(15 * time.Second)
+	timer := time.After(120 * time.Second)
 LockWaitLoop:
 	for {
 		files, err := dir.ListFiles()
@@ -137,10 +137,14 @@ LockWaitLoop:
 		}
 	}
 
-	if runtime.GOOS == "windows" && !s.Testing {
+	if runtime.GOOS != "darwin" && !s.Testing {
 		// Windows takes a while to yield control of the files when the
-		// process is exiting. We just sleep here. In the future, it'd be
-		// nice to find a better solution to this.
+		// process is exiting. Ubuntu will yield control of the files but
+		// VMWare may overwrite the VMX cleanup steps that run after this,
+		// so we wait to ensure VMWare has exited and flushed the VMX.
+
+		// We just sleep here. In the future, it'd be nice to find a better
+		// solution to this.
 		time.Sleep(5 * time.Second)
 	}
 
diff --git a/builder/vmware/iso/step_type_boot_command.go b/builder/vmware/common/step_type_boot_command.go
similarity index 91%
rename from builder/vmware/iso/step_type_boot_command.go
rename to builder/vmware/common/step_type_boot_command.go
index 4dbc7f82d..82e8b3e17 100644
--- a/builder/vmware/iso/step_type_boot_command.go
+++ b/builder/vmware/common/step_type_boot_command.go
@@ -1,11 +1,7 @@
-package iso
+package common
 
 import (
 	"fmt"
-	"github.com/mitchellh/go-vnc"
-	"github.com/mitchellh/multistep"
-	vmwcommon "github.com/mitchellh/packer/builder/vmware/common"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"net"
 	"runtime"
@@ -13,6 +9,10 @@ import (
 	"time"
 	"unicode"
 	"unicode/utf8"
+
+	"github.com/mitchellh/go-vnc"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 const KeyLeftShift uint32 = 0xFFE1
@@ -26,18 +26,20 @@ type bootCommandTemplateData struct {
 // This step "types" the boot command into the VM over VNC.
 //
 // Uses:
-//   config *config
 //   http_port int
 //   ui     packer.Ui
 //   vnc_port uint
 //
 // Produces:
 //   <nothing>
-type stepTypeBootCommand struct{}
+type StepTypeBootCommand struct {
+	BootCommand []string
+	VMName      string
+	Tpl         *packer.ConfigTemplate
+}
 
-func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vmwcommon.Driver)
+func (s *StepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
 	httpPort := state.Get("http_port").(uint)
 	ui := state.Get("ui").(packer.Ui)
 	vncIp := state.Get("vnc_ip").(string)
@@ -88,12 +90,12 @@ func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction
 	tplData := &bootCommandTemplateData{
 		hostIp,
 		httpPort,
-		config.VMName,
+		s.VMName,
 	}
 
 	ui.Say("Typing the boot command over VNC...")
-	for _, command := range config.BootCommand {
-		command, err := config.tpl.Process(command, tplData)
+	for _, command := range s.BootCommand {
+		command, err := s.Tpl.Process(command, tplData)
 		if err != nil {
 			err := fmt.Errorf("Error preparing boot command: %s", err)
 			state.Put("error", err)
@@ -113,7 +115,7 @@ func (s *stepTypeBootCommand) Run(state multistep.StateBag) multistep.StepAction
 	return multistep.ActionContinue
 }
 
-func (*stepTypeBootCommand) Cleanup(multistep.StateBag) {}
+func (*StepTypeBootCommand) Cleanup(multistep.StateBag) {}
 
 func vncSendString(c *vnc.ClientConn, original string) {
 	// Scancodes reference: https://github.com/qemu/qemu/blob/master/ui/vnc_keysym.h
diff --git a/builder/vmware/iso/step_upload_tools.go b/builder/vmware/common/step_upload_tools.go
similarity index 57%
rename from builder/vmware/iso/step_upload_tools.go
rename to builder/vmware/common/step_upload_tools.go
index 3fdf5db4d..03387a13f 100644
--- a/builder/vmware/iso/step_upload_tools.go
+++ b/builder/vmware/common/step_upload_tools.go
@@ -1,9 +1,8 @@
-package iso
+package common
 
 import (
 	"fmt"
 	"github.com/mitchellh/multistep"
-	vmwcommon "github.com/mitchellh/packer/builder/vmware/common"
 	"github.com/mitchellh/packer/packer"
 	"os"
 )
@@ -12,20 +11,24 @@ type toolsUploadPathTemplate struct {
 	Flavor string
 }
 
-type stepUploadTools struct{}
+type StepUploadTools struct {
+	RemoteType        string
+	ToolsUploadFlavor string
+	ToolsUploadPath   string
+	Tpl               *packer.ConfigTemplate
+}
 
-func (*stepUploadTools) Run(state multistep.StateBag) multistep.StepAction {
-	config := state.Get("config").(*config)
-	driver := state.Get("driver").(vmwcommon.Driver)
+func (c *StepUploadTools) Run(state multistep.StateBag) multistep.StepAction {
+	driver := state.Get("driver").(Driver)
 
-	if config.RemoteType == "esx5" {
+	if c.RemoteType == "esx5" {
 		if err := driver.ToolsInstall(); err != nil {
-			state.Put("error", fmt.Errorf("Couldn't mount VMware tools ISO."))
+			state.Put("error", fmt.Errorf("Couldn't mount VMware tools ISO. Please check the 'guest_os_type' in your template.json."))
 		}
 		return multistep.ActionContinue
 	}
 
-	if config.ToolsUploadFlavor == "" {
+	if c.ToolsUploadFlavor == "" {
 		return multistep.ActionContinue
 	}
 
@@ -33,7 +36,7 @@ func (*stepUploadTools) Run(state multistep.StateBag) multistep.StepAction {
 	tools_source := state.Get("tools_upload_source").(string)
 	ui := state.Get("ui").(packer.Ui)
 
-	ui.Say(fmt.Sprintf("Uploading the '%s' VMware Tools", config.ToolsUploadFlavor))
+	ui.Say(fmt.Sprintf("Uploading the '%s' VMware Tools", c.ToolsUploadFlavor))
 	f, err := os.Open(tools_source)
 	if err != nil {
 		state.Put("error", fmt.Errorf("Error opening VMware Tools ISO: %s", err))
@@ -41,8 +44,10 @@ func (*stepUploadTools) Run(state multistep.StateBag) multistep.StepAction {
 	}
 	defer f.Close()
 
-	tplData := &toolsUploadPathTemplate{Flavor: config.ToolsUploadFlavor}
-	config.ToolsUploadPath, err = config.tpl.Process(config.ToolsUploadPath, tplData)
+	tplData := &toolsUploadPathTemplate{
+		Flavor: c.ToolsUploadFlavor,
+	}
+	c.ToolsUploadPath, err = c.Tpl.Process(c.ToolsUploadPath, tplData)
 	if err != nil {
 		err := fmt.Errorf("Error preparing upload path: %s", err)
 		state.Put("error", err)
@@ -50,7 +55,7 @@ func (*stepUploadTools) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
-	if err := comm.Upload(config.ToolsUploadPath, f); err != nil {
+	if err := comm.Upload(c.ToolsUploadPath, f, nil); err != nil {
 		err := fmt.Errorf("Error uploading VMware Tools: %s", err)
 		state.Put("error", err)
 		ui.Error(err.Error())
@@ -60,4 +65,4 @@ func (*stepUploadTools) Run(state multistep.StateBag) multistep.StepAction {
 	return multistep.ActionContinue
 }
 
-func (*stepUploadTools) Cleanup(multistep.StateBag) {}
+func (c *StepUploadTools) Cleanup(multistep.StateBag) {}
diff --git a/builder/vmware/common/tools_config.go b/builder/vmware/common/tools_config.go
new file mode 100644
index 000000000..c50c22e6b
--- /dev/null
+++ b/builder/vmware/common/tools_config.go
@@ -0,0 +1,38 @@
+package common
+
+import (
+	"fmt"
+	"text/template"
+
+	"github.com/mitchellh/packer/packer"
+)
+
+type ToolsConfig struct {
+	ToolsUploadFlavor string `mapstructure:"tools_upload_flavor"`
+	ToolsUploadPath   string `mapstructure:"tools_upload_path"`
+}
+
+func (c *ToolsConfig) Prepare(t *packer.ConfigTemplate) []error {
+	if c.ToolsUploadPath == "" {
+		c.ToolsUploadPath = "{{ .Flavor }}.iso"
+	}
+
+	templates := map[string]*string{
+		"tools_upload_flavor": &c.ToolsUploadFlavor,
+	}
+
+	var err error
+	errs := make([]error, 0)
+	for n, ptr := range templates {
+		*ptr, err = t.Process(*ptr, nil)
+		if err != nil {
+			errs = append(errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
+	if _, err := template.New("path").Parse(c.ToolsUploadPath); err != nil {
+		errs = append(errs, fmt.Errorf("tools_upload_path invalid: %s", err))
+	}
+
+	return errs
+}
diff --git a/builder/vmware/common/vmx_config.go b/builder/vmware/common/vmx_config.go
index f876d584b..98bf70a31 100644
--- a/builder/vmware/common/vmx_config.go
+++ b/builder/vmware/common/vmx_config.go
@@ -7,7 +7,8 @@ import (
 )
 
 type VMXConfig struct {
-	VMXData map[string]string `mapstructure:"vmx_data"`
+	VMXData     map[string]string `mapstructure:"vmx_data"`
+	VMXDataPost map[string]string `mapstructure:"vmx_data_post"`
 }
 
 func (c *VMXConfig) Prepare(t *packer.ConfigTemplate) []error {
@@ -18,14 +19,14 @@ func (c *VMXConfig) Prepare(t *packer.ConfigTemplate) []error {
 		k, err = t.Process(k, nil)
 		if err != nil {
 			errs = append(errs,
-				fmt.Errorf("Error processing VMX data key %s: %s", k, err))
+				fmt.Errorf("Error processing vmx_data key %s: %s", k, err))
 			continue
 		}
 
 		v, err = t.Process(v, nil)
 		if err != nil {
 			errs = append(errs,
-				fmt.Errorf("Error processing VMX data value '%s': %s", v, err))
+				fmt.Errorf("Error processing vmx_data value '%s': %s", v, err))
 			continue
 		}
 
@@ -33,5 +34,26 @@ func (c *VMXConfig) Prepare(t *packer.ConfigTemplate) []error {
 	}
 	c.VMXData = newVMXData
 
+	newVMXDataPost := make(map[string]string)
+	for k, v := range c.VMXDataPost {
+		var err error
+		k, err = t.Process(k, nil)
+		if err != nil {
+			errs = append(errs,
+				fmt.Errorf("Error processing vmx_post_data key %s: %s", k, err))
+			continue
+		}
+
+		v, err = t.Process(v, nil)
+		if err != nil {
+			errs = append(errs,
+				fmt.Errorf("Error processing vmx_post_data value '%s': %s", v, err))
+			continue
+		}
+
+		newVMXDataPost[k] = v
+	}
+	c.VMXDataPost = newVMXDataPost
+
 	return errs
 }
diff --git a/builder/vmware/iso/artifact.go b/builder/vmware/iso/artifact.go
index d6ddf8921..d0e1a6d8b 100644
--- a/builder/vmware/iso/artifact.go
+++ b/builder/vmware/iso/artifact.go
@@ -28,6 +28,10 @@ func (a *Artifact) String() string {
 	return fmt.Sprintf("VM files in directory: %s", a.dir)
 }
 
+func (a *Artifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *Artifact) Destroy() error {
 	return a.dir.RemoveAll()
 }
diff --git a/builder/vmware/iso/builder.go b/builder/vmware/iso/builder.go
index 06884ad89..aeda7ff41 100644
--- a/builder/vmware/iso/builder.go
+++ b/builder/vmware/iso/builder.go
@@ -12,7 +12,6 @@ import (
 	"math/rand"
 	"os"
 	"strings"
-	"text/template"
 	"time"
 )
 
@@ -30,34 +29,31 @@ type config struct {
 	vmwcommon.RunConfig      `mapstructure:",squash"`
 	vmwcommon.ShutdownConfig `mapstructure:",squash"`
 	vmwcommon.SSHConfig      `mapstructure:",squash"`
+	vmwcommon.ToolsConfig    `mapstructure:",squash"`
 	vmwcommon.VMXConfig      `mapstructure:",squash"`
 
-	DiskName          string   `mapstructure:"vmdk_name"`
-	DiskSize          uint     `mapstructure:"disk_size"`
-	DiskTypeId        string   `mapstructure:"disk_type_id"`
-	FloppyFiles       []string `mapstructure:"floppy_files"`
-	GuestOSType       string   `mapstructure:"guest_os_type"`
-	ISOChecksum       string   `mapstructure:"iso_checksum"`
-	ISOChecksumType   string   `mapstructure:"iso_checksum_type"`
-	ISOUrls           []string `mapstructure:"iso_urls"`
-	VMName            string   `mapstructure:"vm_name"`
-	HTTPDir           string   `mapstructure:"http_directory"`
-	HTTPPortMin       uint     `mapstructure:"http_port_min"`
-	HTTPPortMax       uint     `mapstructure:"http_port_max"`
-	BootCommand       []string `mapstructure:"boot_command"`
-	SkipCompaction    bool     `mapstructure:"skip_compaction"`
-	ToolsUploadFlavor string   `mapstructure:"tools_upload_flavor"`
-	ToolsUploadPath   string   `mapstructure:"tools_upload_path"`
-	VMXTemplatePath   string   `mapstructure:"vmx_template_path"`
-	VNCPortMin        uint     `mapstructure:"vnc_port_min"`
-	VNCPortMax        uint     `mapstructure:"vnc_port_max"`
+	DiskName        string   `mapstructure:"vmdk_name"`
+	DiskSize        uint     `mapstructure:"disk_size"`
+	DiskTypeId      string   `mapstructure:"disk_type_id"`
+	FloppyFiles     []string `mapstructure:"floppy_files"`
+	GuestOSType     string   `mapstructure:"guest_os_type"`
+	ISOChecksum     string   `mapstructure:"iso_checksum"`
+	ISOChecksumType string   `mapstructure:"iso_checksum_type"`
+	ISOUrls         []string `mapstructure:"iso_urls"`
+	Version         string   `mapstructure:"version"`
+	VMName          string   `mapstructure:"vm_name"`
+	BootCommand     []string `mapstructure:"boot_command"`
+	SkipCompaction  bool     `mapstructure:"skip_compaction"`
+	VMXTemplatePath string   `mapstructure:"vmx_template_path"`
 
-	RemoteType      string `mapstructure:"remote_type"`
-	RemoteDatastore string `mapstructure:"remote_datastore"`
-	RemoteHost      string `mapstructure:"remote_host"`
-	RemotePort      uint   `mapstructure:"remote_port"`
-	RemoteUser      string `mapstructure:"remote_username"`
-	RemotePassword  string `mapstructure:"remote_password"`
+	RemoteType           string `mapstructure:"remote_type"`
+	RemoteDatastore      string `mapstructure:"remote_datastore"`
+	RemoteCacheDatastore string `mapstructure:"remote_cache_datastore"`
+	RemoteCacheDirectory string `mapstructure:"remote_cache_directory"`
+	RemoteHost           string `mapstructure:"remote_host"`
+	RemotePort           uint   `mapstructure:"remote_port"`
+	RemoteUser           string `mapstructure:"remote_username"`
+	RemotePassword       string `mapstructure:"remote_password"`
 
 	RawSingleISOUrl string `mapstructure:"iso_url"`
 
@@ -84,6 +80,7 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 	errs = packer.MultiErrorAppend(errs, b.config.RunConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.ShutdownConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.SSHConfig.Prepare(b.config.tpl)...)
+	errs = packer.MultiErrorAppend(errs, b.config.ToolsConfig.Prepare(b.config.tpl)...)
 	errs = packer.MultiErrorAppend(errs, b.config.VMXConfig.Prepare(b.config.tpl)...)
 	warnings := make([]string, 0)
 
@@ -116,20 +113,8 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.VMName = fmt.Sprintf("packer-%s", b.config.PackerBuildName)
 	}
 
-	if b.config.HTTPPortMin == 0 {
-		b.config.HTTPPortMin = 8000
-	}
-
-	if b.config.HTTPPortMax == 0 {
-		b.config.HTTPPortMax = 9000
-	}
-
-	if b.config.VNCPortMin == 0 {
-		b.config.VNCPortMin = 5900
-	}
-
-	if b.config.VNCPortMax == 0 {
-		b.config.VNCPortMax = 6000
+	if b.config.Version == "" {
+		b.config.Version = "9"
 	}
 
 	if b.config.RemoteUser == "" {
@@ -140,30 +125,34 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		b.config.RemoteDatastore = "datastore1"
 	}
 
+	if b.config.RemoteCacheDatastore == "" {
+		b.config.RemoteCacheDatastore = b.config.RemoteDatastore
+	}
+
+	if b.config.RemoteCacheDirectory == "" {
+		b.config.RemoteCacheDirectory = "packer_cache"
+	}
+
 	if b.config.RemotePort == 0 {
 		b.config.RemotePort = 22
 	}
 
-	if b.config.ToolsUploadPath == "" {
-		b.config.ToolsUploadPath = "{{ .Flavor }}.iso"
-	}
-
 	// Errors
 	templates := map[string]*string{
-		"disk_name":           &b.config.DiskName,
-		"guest_os_type":       &b.config.GuestOSType,
-		"http_directory":      &b.config.HTTPDir,
-		"iso_checksum":        &b.config.ISOChecksum,
-		"iso_checksum_type":   &b.config.ISOChecksumType,
-		"iso_url":             &b.config.RawSingleISOUrl,
-		"tools_upload_flavor": &b.config.ToolsUploadFlavor,
-		"vm_name":             &b.config.VMName,
-		"vmx_template_path":   &b.config.VMXTemplatePath,
-		"remote_type":         &b.config.RemoteType,
-		"remote_host":         &b.config.RemoteHost,
-		"remote_datastore":    &b.config.RemoteDatastore,
-		"remote_user":         &b.config.RemoteUser,
-		"remote_password":     &b.config.RemotePassword,
+		"disk_name":              &b.config.DiskName,
+		"guest_os_type":          &b.config.GuestOSType,
+		"iso_checksum":           &b.config.ISOChecksum,
+		"iso_checksum_type":      &b.config.ISOChecksumType,
+		"iso_url":                &b.config.RawSingleISOUrl,
+		"vm_name":                &b.config.VMName,
+		"vmx_template_path":      &b.config.VMXTemplatePath,
+		"remote_type":            &b.config.RemoteType,
+		"remote_host":            &b.config.RemoteHost,
+		"remote_datastore":       &b.config.RemoteDatastore,
+		"remote_cache_datastore": &b.config.RemoteCacheDatastore,
+		"remote_cache_directory": &b.config.RemoteCacheDirectory,
+		"remote_user":            &b.config.RemoteUser,
+		"remote_password":        &b.config.RemotePassword,
 	}
 
 	for n, ptr := range templates {
@@ -201,11 +190,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	if b.config.HTTPPortMin > b.config.HTTPPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, errors.New("http_port_min must be less than http_port_max"))
-	}
-
 	if b.config.ISOChecksumType == "" {
 		errs = packer.MultiErrorAppend(
 			errs, errors.New("The iso_checksum_type must be specified."))
@@ -245,11 +229,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 		}
 	}
 
-	if _, err := template.New("path").Parse(b.config.ToolsUploadPath); err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("tools_upload_path invalid: %s", err))
-	}
-
 	if b.config.VMXTemplatePath != "" {
 		if err := b.validateVMXTemplatePath(); err != nil {
 			errs = packer.MultiErrorAppend(
@@ -258,11 +237,6 @@ func (b *Builder) Prepare(raws ...interface{}) ([]string, error) {
 
 	}
 
-	if b.config.VNCPortMin > b.config.VNCPortMax {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("vnc_port_min must be less than vnc_port_max"))
-	}
-
 	// Remote configuration validation
 	if b.config.RemoteType != "" {
 		if b.config.RemoteHost == "" {
@@ -320,7 +294,10 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 	rand.Seed(time.Now().UTC().UnixNano())
 
 	steps := []multistep.Step{
-		&stepPrepareTools{},
+		&vmwcommon.StepPrepareTools{
+			RemoteType:        b.config.RemoteType,
+			ToolsUploadFlavor: b.config.ToolsUploadFlavor,
+		},
 		&common.StepDownload{
 			Checksum:     b.config.ISOChecksum,
 			ChecksumType: b.config.ISOChecksumType,
@@ -334,6 +311,10 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 		&common.StepCreateFloppy{
 			Files: b.config.FloppyFiles,
 		},
+		&stepRemoteUpload{
+			Key:     "floppy_path",
+			Message: "Uploading Floppy to remote machine...",
+		},
 		&stepRemoteUpload{
 			Key:     "iso_path",
 			Message: "Uploading ISO to remote machine...",
@@ -344,28 +325,48 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			CustomData: b.config.VMXData,
 		},
 		&vmwcommon.StepSuppressMessages{},
-		&stepHTTPServer{},
-		&stepConfigureVNC{},
+		&vmwcommon.StepHTTPServer{
+			HTTPDir:     b.config.HTTPDir,
+			HTTPPortMin: b.config.HTTPPortMin,
+			HTTPPortMax: b.config.HTTPPortMax,
+		},
+		&vmwcommon.StepConfigureVNC{
+			VNCPortMin: b.config.VNCPortMin,
+			VNCPortMax: b.config.VNCPortMax,
+		},
 		&StepRegister{},
 		&vmwcommon.StepRun{
 			BootWait:           b.config.BootWait,
 			DurationBeforeStop: 5 * time.Second,
 			Headless:           b.config.Headless,
 		},
-		&stepTypeBootCommand{},
+		&vmwcommon.StepTypeBootCommand{
+			BootCommand: b.config.BootCommand,
+			VMName:      b.config.VMName,
+			Tpl:         b.config.tpl,
+		},
 		&common.StepConnectSSH{
 			SSHAddress:     driver.SSHAddress,
 			SSHConfig:      vmwcommon.SSHConfigFunc(&b.config.SSHConfig),
 			SSHWaitTimeout: b.config.SSHWaitTimeout,
 			NoPty:          b.config.SSHSkipRequestPty,
 		},
-		&stepUploadTools{},
+		&vmwcommon.StepUploadTools{
+			RemoteType:        b.config.RemoteType,
+			ToolsUploadFlavor: b.config.ToolsUploadFlavor,
+			ToolsUploadPath:   b.config.ToolsUploadPath,
+			Tpl:               b.config.tpl,
+		},
 		&common.StepProvision{},
 		&vmwcommon.StepShutdown{
 			Command: b.config.ShutdownCommand,
 			Timeout: b.config.ShutdownTimeout,
 		},
 		&vmwcommon.StepCleanFiles{},
+		&vmwcommon.StepConfigureVMX{
+			CustomData: b.config.VMXDataPost,
+			SkipFloppy: true,
+		},
 		&vmwcommon.StepCleanVMX{},
 		&vmwcommon.StepCompactDisk{
 			Skip: b.config.SkipCompaction,
diff --git a/builder/vmware/iso/builder_test.go b/builder/vmware/iso/builder_test.go
index f3c1dfd59..b6c0cfd81 100644
--- a/builder/vmware/iso/builder_test.go
+++ b/builder/vmware/iso/builder_test.go
@@ -134,6 +134,10 @@ func TestBuilderPrepare_Defaults(t *testing.T) {
 		t.Errorf("bad output dir: %s", b.config.OutputDir)
 	}
 
+	if b.config.Version != "9" {
+		t.Errorf("bad Version: %s", b.config.Version)
+	}
+
 	if b.config.SSHWaitTimeout != (20 * time.Minute) {
 		t.Errorf("bad wait timeout: %s", b.config.SSHWaitTimeout)
 	}
diff --git a/builder/vmware/iso/driver.go b/builder/vmware/iso/driver.go
index ebe8d126b..e98019a7e 100644
--- a/builder/vmware/iso/driver.go
+++ b/builder/vmware/iso/driver.go
@@ -17,11 +17,13 @@ func NewDriver(config *config) (vmwcommon.Driver, error) {
 
 	drivers = []vmwcommon.Driver{
 		&ESX5Driver{
-			Host:      config.RemoteHost,
-			Port:      config.RemotePort,
-			Username:  config.RemoteUser,
-			Password:  config.RemotePassword,
-			Datastore: config.RemoteDatastore,
+			Host:           config.RemoteHost,
+			Port:           config.RemotePort,
+			Username:       config.RemoteUser,
+			Password:       config.RemotePassword,
+			Datastore:      config.RemoteDatastore,
+			CacheDatastore: config.RemoteCacheDatastore,
+			CacheDirectory: config.RemoteCacheDirectory,
 		},
 	}
 
diff --git a/builder/vmware/iso/driver_esx5.go b/builder/vmware/iso/driver_esx5.go
index 8fbba7106..ca1733d63 100644
--- a/builder/vmware/iso/driver_esx5.go
+++ b/builder/vmware/iso/driver_esx5.go
@@ -16,18 +16,19 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"syscall"
 	"time"
 )
 
 // ESX5 driver talks to an ESXi5 hypervisor remotely over SSH to build
 // virtual machines. This driver can only manage one machine at a time.
 type ESX5Driver struct {
-	Host      string
-	Port      uint
-	Username  string
-	Password  string
-	Datastore string
+	Host           string
+	Port           uint
+	Username       string
+	Password       string
+	Datastore      string
+	CacheDatastore string
+	CacheDirectory string
 
 	comm      packer.Communicator
 	outputDir string
@@ -56,7 +57,21 @@ func (d *ESX5Driver) IsRunning(string) (bool, error) {
 }
 
 func (d *ESX5Driver) Start(vmxPathLocal string, headless bool) error {
-	return d.sh("vim-cmd", "vmsvc/power.on", d.vmId)
+	for i := 0; i < 20; i++ {
+		err := d.sh("vim-cmd", "vmsvc/power.on", d.vmId)
+		if err != nil {
+			return err
+		}
+		time.Sleep((time.Duration(i) * time.Second) + 1)
+		running, err := d.IsRunning(vmxPathLocal)
+		if err != nil {
+			return err
+		}
+		if running {
+			return nil
+		}
+	}
+	return errors.New("Retry limit exceeded")
 }
 
 func (d *ESX5Driver) Stop(vmxPathLocal string) error {
@@ -64,7 +79,7 @@ func (d *ESX5Driver) Stop(vmxPathLocal string) error {
 }
 
 func (d *ESX5Driver) Register(vmxPathLocal string) error {
-	vmxPath := filepath.Join(d.outputDir, filepath.Base(vmxPathLocal))
+	vmxPath := filepath.ToSlash(filepath.Join(d.outputDir, filepath.Base(vmxPathLocal)))
 	if err := d.upload(vmxPath, vmxPathLocal); err != nil {
 		return err
 	}
@@ -84,16 +99,16 @@ func (d *ESX5Driver) Unregister(vmxPathLocal string) error {
 	return d.sh("vim-cmd", "vmsvc/unregister", d.vmId)
 }
 
-func (d *ESX5Driver) UploadISO(localPath string) (string, error) {
-	cacheRoot, _ := filepath.Abs(".")
-	targetFile, err := filepath.Rel(cacheRoot, localPath)
-	if err != nil {
+func (d *ESX5Driver) UploadISO(localPath string, checksum string, checksumType string) (string, error) {
+	finalPath := d.cachePath(localPath)
+	if err := d.mkdir(filepath.ToSlash(filepath.Dir(finalPath))); err != nil {
 		return "", err
 	}
 
-	finalPath := d.datastorePath(targetFile)
-	if err := d.mkdir(filepath.Dir(finalPath)); err != nil {
-		return "", err
+	log.Printf("Verifying checksum of %s", finalPath)
+	if d.verifyChecksum(checksumType, checksum, finalPath) {
+		log.Println("Initial checksum matched, no upload needed.")
+		return finalPath, nil
 	}
 
 	if err := d.upload(finalPath, localPath); err != nil {
@@ -142,29 +157,60 @@ func (d *ESX5Driver) HostIP() (string, error) {
 	return host, err
 }
 
-func (d *ESX5Driver) VNCAddress(portMin, portMax uint) (string, uint) {
+func (d *ESX5Driver) VNCAddress(portMin, portMax uint) (string, uint, error) {
 	var vncPort uint
-	// TODO(dougm) use esxcli network ip connection list
-	for port := portMin; port <= portMax; port++ {
-		address := fmt.Sprintf("%s:%d", d.Host, port)
-		log.Printf("Trying address: %s...", address)
-		l, err := net.DialTimeout("tcp", address, 1*time.Second)
 
-		if err == nil {
-			log.Printf("%s in use", address)
-			l.Close()
-		} else if e, ok := err.(*net.OpError); ok {
-			if e.Err == syscall.ECONNREFUSED {
-				// then port should be available for listening
-				vncPort = port
-				break
-			} else if e.Timeout() {
-				log.Printf("Timeout connecting to: %s (check firewall rules)", address)
+	//Process ports ESXi is listening on to determine which are available
+	//This process does best effort to detect ports that are unavailable,
+	//it will ignore any ports listened to by only localhost
+	r, err := d.esxcli("network", "ip", "connection", "list")
+	if err != nil {
+		err = fmt.Errorf("Could not retrieve network information for ESXi: %v", err)
+		return "", 0, err
+	}
+
+	listenPorts := make(map[string]bool)
+	for record, err := r.read(); record != nil && err == nil; record, err = r.read() {
+		if record["State"] == "LISTEN" {
+			splitAddress := strings.Split(record["LocalAddress"], ":")
+			if splitAddress[0] != "127.0.0.1" {
+				port := splitAddress[len(splitAddress)-1]
+				log.Printf("ESXi listening on address %s, port %s unavailable for VNC", record["LocalAddress"], port)
+				listenPorts[port] = true
 			}
 		}
 	}
 
-	return d.Host, vncPort
+	for port := portMin; port <= portMax; port++ {
+		if _, ok := listenPorts[fmt.Sprintf("%d", port)]; ok {
+			log.Printf("Port %d in use", port)
+			continue
+		}
+		address := fmt.Sprintf("%s:%d", d.Host, port)
+		log.Printf("Trying address: %s...", address)
+		l, err := net.DialTimeout("tcp", address, 1*time.Second)
+
+		if err != nil {
+			if e, ok := err.(*net.OpError); ok {
+				if e.Timeout() {
+					log.Printf("Timeout connecting to: %s (check firewall rules)", address)
+				} else {
+					vncPort = port
+					break
+				}
+			}
+		} else {
+			defer l.Close()
+		}
+	}
+
+	if vncPort == 0 {
+		err := fmt.Errorf("Unable to find available VNC port between %d and %d",
+			portMin, portMax)
+		return d.Host, vncPort, err
+	}
+
+	return d.Host, vncPort, nil
 }
 
 func (d *ESX5Driver) SSHAddress(state multistep.StateBag) (string, error) {
@@ -174,18 +220,35 @@ func (d *ESX5Driver) SSHAddress(state multistep.StateBag) (string, error) {
 		return address.(string), nil
 	}
 
-	r, err := d.run(nil, "vim-cmd", "vmsvc/get.guest", d.vmId, " | grep -m 1 ipAddress | awk -F'\"' '{print $2}'")
+	r, err := d.esxcli("network", "vm", "list")
 	if err != nil {
 		return "", err
 	}
 
-	ipAddress := strings.TrimRight(r, "\n")
+	record, err := r.find("Name", config.VMName)
+	if err != nil {
+		return "", err
+	}
+	wid := record["WorldID"]
+	if wid == "" {
+		return "", errors.New("VM WorldID not found")
+	}
 
-	if ipAddress == "" {
+	r, err = d.esxcli("network", "vm", "port", "list", "-w", wid)
+	if err != nil {
+		return "", err
+	}
+
+	record, err = r.read()
+	if err != nil {
+		return "", err
+	}
+
+	if record["IPAddress"] == "0.0.0.0" {
 		return "", errors.New("VM network port found, but no IP address")
 	}
 
-	address := fmt.Sprintf("%s:%d", ipAddress, config.SSHPort)
+	address := fmt.Sprintf("%s:%d", record["IPAddress"], config.SSHPort)
 	state.Put("vm_address", address)
 	return address, nil
 }
@@ -216,7 +279,7 @@ func (d *ESX5Driver) ListFiles() ([]string, error) {
 			continue
 		}
 
-		files = append(files, filepath.Join(d.outputDir, string(line)))
+		files = append(files, filepath.ToSlash(filepath.Join(d.outputDir, string(line))))
 	}
 
 	return files, nil
@@ -243,7 +306,12 @@ func (d *ESX5Driver) String() string {
 }
 
 func (d *ESX5Driver) datastorePath(path string) string {
-	return filepath.Join("/vmfs/volumes", d.Datastore, path)
+	baseDir := filepath.Base(filepath.Dir(path))
+	return filepath.ToSlash(filepath.Join("/vmfs/volumes", d.Datastore, baseDir, filepath.Base(path)))
+}
+
+func (d *ESX5Driver) cachePath(path string) string {
+	return filepath.ToSlash(filepath.Join("/vmfs/volumes", d.CacheDatastore, d.CacheDirectory, filepath.Base(path)))
 }
 
 func (d *ESX5Driver) connect() error {
@@ -320,7 +388,7 @@ func (d *ESX5Driver) upload(dst, src string) error {
 		return err
 	}
 	defer f.Close()
-	return d.comm.Upload(dst, f)
+	return d.comm.Upload(dst, f, nil)
 }
 
 func (d *ESX5Driver) verifyChecksum(ctype string, hash string, file string) bool {
diff --git a/builder/vmware/iso/remote_driver.go b/builder/vmware/iso/remote_driver.go
index d020cb800..b597d530a 100644
--- a/builder/vmware/iso/remote_driver.go
+++ b/builder/vmware/iso/remote_driver.go
@@ -10,7 +10,7 @@ type RemoteDriver interface {
 	// UploadISO uploads a local ISO to the remote side and returns the
 	// new path that should be used in the VMX along with an error if it
 	// exists.
-	UploadISO(string) (string, error)
+	UploadISO(string, string, string) (string, error)
 
 	// Adds a VM to inventory specified by the path to the VMX given.
 	Register(string) error
diff --git a/builder/vmware/iso/remote_driver_mock.go b/builder/vmware/iso/remote_driver_mock.go
index fe494fd86..233056ae3 100644
--- a/builder/vmware/iso/remote_driver_mock.go
+++ b/builder/vmware/iso/remote_driver_mock.go
@@ -21,7 +21,7 @@ type RemoteDriverMock struct {
 	UnregisterErr    error
 }
 
-func (d *RemoteDriverMock) UploadISO(path string) (string, error) {
+func (d *RemoteDriverMock) UploadISO(path string, checksum string, checksumType string) (string, error) {
 	d.UploadISOCalled = true
 	d.UploadISOPath = path
 	return d.UploadISOResult, d.UploadISOErr
diff --git a/builder/vmware/iso/step_create_vmx.go b/builder/vmware/iso/step_create_vmx.go
index 8544a1405..e490e639b 100644
--- a/builder/vmware/iso/step_create_vmx.go
+++ b/builder/vmware/iso/step_create_vmx.go
@@ -15,6 +15,7 @@ type vmxTemplateData struct {
 	GuestOS  string
 	DiskName string
 	ISOPath  string
+	Version  string
 }
 
 // This step creates the VMX file for the VM.
@@ -41,6 +42,7 @@ func (s *stepCreateVMX) Run(state multistep.StateBag) multistep.StepAction {
 		Name:     config.VMName,
 		GuestOS:  config.GuestOSType,
 		DiskName: config.DiskName,
+		Version:  config.Version,
 		ISOPath:  isoPath,
 	}
 
@@ -180,7 +182,7 @@ tools.upgrade.policy = "upgradeAtPowerCycle"
 usb.pciSlotNumber = "32"
 usb.present = "FALSE"
 virtualHW.productCompatibility = "hosted"
-virtualHW.version = "9"
+virtualHW.version = "{{ .Version }}"
 vmci0.id = "1861462627"
 vmci0.pciSlotNumber = "35"
 vmci0.present = "TRUE"
diff --git a/builder/vmware/iso/step_remote_upload.go b/builder/vmware/iso/step_remote_upload.go
index 717b3dc13..927c16c2a 100644
--- a/builder/vmware/iso/step_remote_upload.go
+++ b/builder/vmware/iso/step_remote_upload.go
@@ -24,10 +24,18 @@ func (s *stepRemoteUpload) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionContinue
 	}
 
+	path, ok := state.Get(s.Key).(string)
+	if !ok {
+		return multistep.ActionContinue
+	}
+
+	config := state.Get("config").(*config)
+	checksum := config.ISOChecksum
+	checksumType := config.ISOChecksumType
+
 	ui.Say(s.Message)
-	path := state.Get(s.Key).(string)
 	log.Printf("Remote uploading: %s", path)
-	newPath, err := remote.UploadISO(path)
+	newPath, err := remote.UploadISO(path, checksum, checksumType)
 	if err != nil {
 		err := fmt.Errorf("Error uploading file: %s", err)
 		state.Put("error", err)
diff --git a/builder/vmware/vmx/builder.go b/builder/vmware/vmx/builder.go
index dd47598b0..100e1fe36 100644
--- a/builder/vmware/vmx/builder.go
+++ b/builder/vmware/vmx/builder.go
@@ -52,9 +52,16 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 
 	// Build the steps.
 	steps := []multistep.Step{
+		&vmwcommon.StepPrepareTools{
+			RemoteType:        b.config.RemoteType,
+			ToolsUploadFlavor: b.config.ToolsUploadFlavor,
+		},
 		&vmwcommon.StepOutputDir{
 			Force: b.config.PackerForce,
 		},
+		&common.StepCreateFloppy{
+			Files: b.config.FloppyFiles,
+		},
 		&StepCloneVMX{
 			OutputDir: b.config.OutputDir,
 			Path:      b.config.SourcePath,
@@ -64,23 +71,47 @@ func (b *Builder) Run(ui packer.Ui, hook packer.Hook, cache packer.Cache) (packe
 			CustomData: b.config.VMXData,
 		},
 		&vmwcommon.StepSuppressMessages{},
+		&vmwcommon.StepHTTPServer{
+			HTTPDir:     b.config.HTTPDir,
+			HTTPPortMin: b.config.HTTPPortMin,
+			HTTPPortMax: b.config.HTTPPortMax,
+		},
+		&vmwcommon.StepConfigureVNC{
+			VNCPortMin: b.config.VNCPortMin,
+			VNCPortMax: b.config.VNCPortMax,
+		},
 		&vmwcommon.StepRun{
 			BootWait:           b.config.BootWait,
 			DurationBeforeStop: 5 * time.Second,
 			Headless:           b.config.Headless,
 		},
+		&vmwcommon.StepTypeBootCommand{
+			BootCommand: b.config.BootCommand,
+			VMName:      b.config.VMName,
+			Tpl:         b.config.tpl,
+		},
 		&common.StepConnectSSH{
 			SSHAddress:     driver.SSHAddress,
 			SSHConfig:      vmwcommon.SSHConfigFunc(&b.config.SSHConfig),
 			SSHWaitTimeout: b.config.SSHWaitTimeout,
 			NoPty:          b.config.SSHSkipRequestPty,
 		},
+		&vmwcommon.StepUploadTools{
+			RemoteType:        b.config.RemoteType,
+			ToolsUploadFlavor: b.config.ToolsUploadFlavor,
+			ToolsUploadPath:   b.config.ToolsUploadPath,
+			Tpl:               b.config.tpl,
+		},
 		&common.StepProvision{},
 		&vmwcommon.StepShutdown{
 			Command: b.config.ShutdownCommand,
 			Timeout: b.config.ShutdownTimeout,
 		},
 		&vmwcommon.StepCleanFiles{},
+		&vmwcommon.StepConfigureVMX{
+			CustomData: b.config.VMXDataPost,
+			SkipFloppy: true,
+		},
 		&vmwcommon.StepCleanVMX{},
 		&vmwcommon.StepCompactDisk{
 			Skip: b.config.SkipCompaction,
diff --git a/builder/vmware/vmx/builder_test.go b/builder/vmware/vmx/builder_test.go
index e6b128721..f23f2f2e5 100644
--- a/builder/vmware/vmx/builder_test.go
+++ b/builder/vmware/vmx/builder_test.go
@@ -1 +1,50 @@
 package vmx
+
+import (
+	"io/ioutil"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestBuilderPrepare_FloppyFiles(t *testing.T) {
+	var b Builder
+
+	tf, err := ioutil.TempFile("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	tf.Close()
+	defer os.Remove(tf.Name())
+
+	config := testConfig(t)
+	config["source_path"] = tf.Name()
+
+	delete(config, "floppy_files")
+	warns, err := b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("bad err: %s", err)
+	}
+
+	if len(b.config.FloppyFiles) != 0 {
+		t.Fatalf("bad: %#v", b.config.FloppyFiles)
+	}
+
+	config["floppy_files"] = []string{"foo", "bar"}
+	b = Builder{}
+	warns, err = b.Prepare(config)
+	if len(warns) > 0 {
+		t.Fatalf("bad: %#v", warns)
+	}
+	if err != nil {
+		t.Fatalf("should not have error: %s", err)
+	}
+
+	expected := []string{"foo", "bar"}
+	if !reflect.DeepEqual(b.config.FloppyFiles, expected) {
+		t.Fatalf("bad: %#v", b.config.FloppyFiles)
+	}
+}
diff --git a/builder/vmware/vmx/config.go b/builder/vmware/vmx/config.go
index 70f125c0a..575bc7a5b 100644
--- a/builder/vmware/vmx/config.go
+++ b/builder/vmware/vmx/config.go
@@ -17,11 +17,15 @@ type Config struct {
 	vmwcommon.RunConfig      `mapstructure:",squash"`
 	vmwcommon.ShutdownConfig `mapstructure:",squash"`
 	vmwcommon.SSHConfig      `mapstructure:",squash"`
+	vmwcommon.ToolsConfig    `mapstructure:",squash"`
 	vmwcommon.VMXConfig      `mapstructure:",squash"`
 
-	SkipCompaction bool   `mapstructure:"skip_compaction"`
-	SourcePath     string `mapstructure:"source_path"`
-	VMName         string `mapstructure:"vm_name"`
+	BootCommand    []string `mapstructure:"boot_command"`
+	FloppyFiles    []string `mapstructure:"floppy_files"`
+	RemoteType     string   `mapstructure:"remote_type"`
+	SkipCompaction bool     `mapstructure:"skip_compaction"`
+	SourcePath     string   `mapstructure:"source_path"`
+	VMName         string   `mapstructure:"vm_name"`
 
 	tpl *packer.ConfigTemplate
 }
@@ -51,9 +55,11 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 	errs = packer.MultiErrorAppend(errs, c.RunConfig.Prepare(c.tpl)...)
 	errs = packer.MultiErrorAppend(errs, c.ShutdownConfig.Prepare(c.tpl)...)
 	errs = packer.MultiErrorAppend(errs, c.SSHConfig.Prepare(c.tpl)...)
+	errs = packer.MultiErrorAppend(errs, c.ToolsConfig.Prepare(c.tpl)...)
 	errs = packer.MultiErrorAppend(errs, c.VMXConfig.Prepare(c.tpl)...)
 
 	templates := map[string]*string{
+		"remote_type": &c.RemoteType,
 		"source_path": &c.SourcePath,
 		"vm_name":     &c.VMName,
 	}
@@ -67,6 +73,23 @@ func NewConfig(raws ...interface{}) (*Config, []string, error) {
 		}
 	}
 
+	for i, file := range c.FloppyFiles {
+		var err error
+		c.FloppyFiles[i], err = c.tpl.Process(file, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(errs,
+				fmt.Errorf("Error processing floppy_files[%d]: %s",
+					i, err))
+		}
+	}
+
+	for i, command := range c.BootCommand {
+		if err := c.tpl.Validate(command); err != nil {
+			errs = packer.MultiErrorAppend(errs,
+				fmt.Errorf("Error processing boot_command[%d]: %s", i, err))
+		}
+	}
+
 	if c.SourcePath == "" {
 		errs = packer.MultiErrorAppend(errs, fmt.Errorf("source_path is required"))
 	} else {
diff --git a/builder/vmware/vmx/step_clone_vmx.go b/builder/vmware/vmx/step_clone_vmx.go
index c1edcff15..a020e1627 100644
--- a/builder/vmware/vmx/step_clone_vmx.go
+++ b/builder/vmware/vmx/step_clone_vmx.go
@@ -37,8 +37,17 @@ func (s *StepCloneVMX) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionHalt
 	}
 
-	diskName, ok := vmxData["scsi0:0.filename"]
-	if !ok {
+	var diskName string
+	if _, ok := vmxData["scsi0:0.filename"]; ok {
+		diskName = vmxData["scsi0:0.filename"]
+	}
+	if _, ok := vmxData["sata0:0.filename"]; ok {
+		diskName = vmxData["sata0:0.filename"]
+	}
+	if _, ok := vmxData["ide0:0.filename"]; ok {
+		diskName = vmxData["ide0:0.filename"]
+	}
+	if diskName == "" {
 		err := fmt.Errorf("Root disk filename could not be found!")
 		state.Put("error", err)
 		return multistep.ActionHalt
diff --git a/checkpoint.go b/checkpoint.go
new file mode 100644
index 000000000..5d2e486db
--- /dev/null
+++ b/checkpoint.go
@@ -0,0 +1,81 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"path/filepath"
+
+	"github.com/hashicorp/go-checkpoint"
+	"github.com/mitchellh/packer/command"
+)
+
+func init() {
+	checkpointResult = make(chan *checkpoint.CheckResponse, 1)
+}
+
+var checkpointResult chan *checkpoint.CheckResponse
+
+// runCheckpoint runs a HashiCorp Checkpoint request. You can read about
+// Checkpoint here: https://github.com/hashicorp/go-checkpoint.
+func runCheckpoint(c *config) {
+	// If the user doesn't want checkpoint at all, then return.
+	if c.DisableCheckpoint {
+		log.Printf("[INFO] Checkpoint disabled. Not running.")
+		checkpointResult <- nil
+		return
+	}
+
+	configDir, err := ConfigDir()
+	if err != nil {
+		log.Printf("[ERR] Checkpoint setup error: %s", err)
+		checkpointResult <- nil
+		return
+	}
+
+	version := Version
+	if VersionPrerelease != "" {
+		version += fmt.Sprintf(".%s", VersionPrerelease)
+	}
+
+	signaturePath := filepath.Join(configDir, "checkpoint_signature")
+	if c.DisableCheckpointSignature {
+		log.Printf("[INFO] Checkpoint signature disabled")
+		signaturePath = ""
+	}
+
+	resp, err := checkpoint.Check(&checkpoint.CheckParams{
+		Product:       "packer",
+		Version:       version,
+		SignatureFile: signaturePath,
+		CacheFile:     filepath.Join(configDir, "checkpoint_cache"),
+	})
+	if err != nil {
+		log.Printf("[ERR] Checkpoint error: %s", err)
+		resp = nil
+	}
+
+	checkpointResult <- resp
+}
+
+// commandVersionCheck implements command.VersionCheckFunc and is used
+// as the version checker.
+func commandVersionCheck() (command.VersionCheckInfo, error) {
+	// Wait for the result to come through
+	info := <-checkpointResult
+	if info == nil {
+		var zero command.VersionCheckInfo
+		return zero, nil
+	}
+
+	// Build the alerts that we may have received about our version
+	alerts := make([]string, len(info.Alerts))
+	for i, a := range info.Alerts {
+		alerts[i] = a.Message
+	}
+
+	return command.VersionCheckInfo{
+		Outdated: info.Outdated,
+		Latest:   info.CurrentVersion,
+		Alerts:   alerts,
+	}, nil
+}
diff --git a/command/build/command.go b/command/build.go
similarity index 83%
rename from command/build/command.go
rename to command/build.go
index 2b3ceb394..a0b33e530 100644
--- a/command/build/command.go
+++ b/command/build.go
@@ -1,4 +1,4 @@
-package build
+package command
 
 import (
 	"bytes"
@@ -14,20 +14,23 @@ import (
 	"sync"
 )
 
-type Command byte
-
-func (Command) Help() string {
-	return strings.TrimSpace(helpText)
+type BuildCommand struct {
+	Meta
 }
 
-func (c Command) Run(env packer.Environment, args []string) int {
-	var cfgDebug bool
-	var cfgForce bool
-	var cfgParallel bool
+func (c BuildCommand) Run(args []string) int {
+	var cfgColor, cfgDebug, cfgForce, cfgParallel bool
 	buildOptions := new(cmdcommon.BuildOptions)
 
+	env, err := c.Meta.Environment()
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Error initializing environment: %s", err))
+		return 1
+	}
+
 	cmdFlags := flag.NewFlagSet("build", flag.ContinueOnError)
 	cmdFlags.Usage = func() { env.Ui().Say(c.Help()) }
+	cmdFlags.BoolVar(&cfgColor, "color", true, "enable or disable color")
 	cmdFlags.BoolVar(&cfgDebug, "debug", false, "debug mode for builds")
 	cmdFlags.BoolVar(&cfgForce, "force", false, "force a build if artifacts exist")
 	cmdFlags.BoolVar(&cfgParallel, "parallel", true, "enable/disable parallelization")
@@ -95,9 +98,13 @@ func (c Command) Run(env packer.Environment, args []string) int {
 
 	buildUis := make(map[string]packer.Ui)
 	for i, b := range builds {
-		ui := &packer.ColoredUi{
-			Color: colors[i%len(colors)],
-			Ui:    env.Ui(),
+		var ui packer.Ui
+		ui = env.Ui()
+		if cfgColor {
+			ui = &packer.ColoredUi{
+				Color: colors[i%len(colors)],
+				Ui:    env.Ui(),
+			}
 		}
 
 		buildUis[b.Name()] = ui
@@ -275,6 +282,28 @@ func (c Command) Run(env packer.Environment, args []string) int {
 	return 0
 }
 
-func (Command) Synopsis() string {
+func (BuildCommand) Help() string {
+	helpText := `
+Usage: packer build [options] TEMPLATE
+
+  Will execute multiple builds in parallel as defined in the template.
+  The various artifacts created by the template will be outputted.
+
+Options:
+
+  -debug                     Debug mode enabled for builds
+  -force                     Force a build to continue if artifacts exist, deletes existing artifacts
+  -machine-readable          Machine-readable output
+  -except=foo,bar,baz        Build all builds other than these
+  -only=foo,bar,baz          Only build the given builds by name
+  -parallel=false            Disable parallelization (on by default)
+  -var 'key=value'           Variable for templates, can be used multiple times.
+  -var-file=path             JSON file containing user variables.
+`
+
+	return strings.TrimSpace(helpText)
+}
+
+func (BuildCommand) Synopsis() string {
 	return "build image(s) from template"
 }
diff --git a/command/build/command_test.go b/command/build/command_test.go
deleted file mode 100644
index 2edd82b4a..000000000
--- a/command/build/command_test.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package build
-
-import (
-	"bytes"
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func testEnvironment() packer.Environment {
-	config := packer.DefaultEnvironmentConfig()
-	config.Ui = &packer.BasicUi{
-		Reader: new(bytes.Buffer),
-		Writer: new(bytes.Buffer),
-	}
-
-	env, err := packer.NewEnvironment(config)
-	if err != nil {
-		panic(err)
-	}
-
-	return env
-}
-
-func TestCommand_Implements(t *testing.T) {
-	var _ packer.Command = new(Command)
-}
-
-func TestCommand_Run_NoArgs(t *testing.T) {
-	command := new(Command)
-	result := command.Run(testEnvironment(), make([]string, 0))
-	if result != 1 {
-		t.Fatalf("bad: %d", result)
-	}
-}
-
-func TestCommand_Run_MoreThanOneArg(t *testing.T) {
-	command := new(Command)
-
-	args := []string{"one", "two"}
-	result := command.Run(testEnvironment(), args)
-	if result != 1 {
-		t.Fatalf("bad: %d", result)
-	}
-}
-
-func TestCommand_Run_MissingFile(t *testing.T) {
-	command := new(Command)
-
-	args := []string{"i-better-not-exist"}
-	result := command.Run(testEnvironment(), args)
-	if result != 1 {
-		t.Fatalf("bad: %d", result)
-	}
-}
diff --git a/command/build/help.go b/command/build/help.go
deleted file mode 100644
index 5b27a53ad..000000000
--- a/command/build/help.go
+++ /dev/null
@@ -1,19 +0,0 @@
-package build
-
-const helpText = `
-Usage: packer build [options] TEMPLATE
-
-  Will execute multiple builds in parallel as defined in the template.
-  The various artifacts created by the template will be outputted.
-
-Options:
-
-  -debug                     Debug mode enabled for builds
-  -force                     Force a build to continue if artifacts exist, deletes existing artifacts
-  -machine-readable          Machine-readable output
-  -except=foo,bar,baz        Build all builds other than these
-  -only=foo,bar,baz          Only build the given builds by name
-  -parallel=false            Disable parallelization (on by default)
-  -var 'key=value'           Variable for templates, can be used multiple times.
-  -var-file=path             JSON file containing user variables.
-`
diff --git a/command/fix/command.go b/command/fix.go
similarity index 55%
rename from command/fix/command.go
rename to command/fix.go
index c62d3676b..aac0b3916 100644
--- a/command/fix/command.go
+++ b/command/fix.go
@@ -1,23 +1,28 @@
-package fix
+package command
 
 import (
 	"bytes"
 	"encoding/json"
 	"flag"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"os"
 	"strings"
+
+	"github.com/mitchellh/packer/fix"
 )
 
-type Command byte
-
-func (Command) Help() string {
-	return strings.TrimSpace(helpString)
+type FixCommand struct {
+	Meta
 }
 
-func (c Command) Run(env packer.Environment, args []string) int {
+func (c *FixCommand) Run(args []string) int {
+	env, err := c.Meta.Environment()
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Error initializing environment: %s", err))
+		return 1
+	}
+
 	cmdFlags := flag.NewFlagSet("fix", flag.ContinueOnError)
 	cmdFlags.Usage = func() { env.Ui().Say(c.Help()) }
 	if err := cmdFlags.Parse(args); err != nil {
@@ -50,9 +55,9 @@ func (c Command) Run(env packer.Environment, args []string) int {
 	tplF.Close()
 
 	input := templateData
-	for _, name := range FixerOrder {
+	for _, name := range fix.FixerOrder {
 		var err error
-		fixer, ok := Fixers[name]
+		fixer, ok := fix.Fixers[name]
 		if !ok {
 			panic("fixer not found: " + name)
 		}
@@ -85,6 +90,30 @@ func (c Command) Run(env packer.Environment, args []string) int {
 	return 0
 }
 
-func (c Command) Synopsis() string {
+func (*FixCommand) Help() string {
+	helpText := `
+Usage: packer fix [options] TEMPLATE
+
+  Reads the JSON template and attempts to fix known backwards
+  incompatibilities. The fixed template will be outputted to standard out.
+
+  If the template cannot be fixed due to an error, the command will exit
+  with a non-zero exit status. Error messages will appear on standard error.
+
+Fixes that are run:
+
+  iso-md5             Replaces "iso_md5" in builders with newer "iso_checksum"
+  createtime          Replaces ".CreateTime" in builder configs with "{{timestamp}}"
+  virtualbox-gaattach Updates VirtualBox builders using "guest_additions_attach"
+                      to use "guest_additions_mode"
+  pp-vagrant-override Replaces old-style provider overrides for the Vagrant
+                      post-processor to new-style as of Packer 0.5.0.
+  virtualbox-rename   Updates "virtualbox" builders to "virtualbox-iso"
+`
+
+	return strings.TrimSpace(helpText)
+}
+
+func (c *FixCommand) Synopsis() string {
 	return "fixes templates from old versions of packer"
 }
diff --git a/command/fix/command_test.go b/command/fix/command_test.go
deleted file mode 100644
index e6c0c59e4..000000000
--- a/command/fix/command_test.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package fix
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestCommand_Impl(t *testing.T) {
-	var raw interface{}
-	raw = new(Command)
-	if _, ok := raw.(packer.Command); !ok {
-		t.Fatalf("must be a Command")
-	}
-}
diff --git a/command/fix/help.go b/command/fix/help.go
deleted file mode 100644
index 95c5f3e16..000000000
--- a/command/fix/help.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package fix
-
-const helpString = `
-Usage: packer fix [options] TEMPLATE
-
-  Reads the JSON template and attempts to fix known backwards
-  incompatibilities. The fixed template will be outputted to standard out.
-
-  If the template cannot be fixed due to an error, the command will exit
-  with a non-zero exit status. Error messages will appear on standard error.
-
-Fixes that are run:
-
-  iso-md5             Replaces "iso_md5" in builders with newer "iso_checksum"
-  createtime          Replaces ".CreateTime" in builder configs with "{{timestamp}}"
-  virtualbox-gaattach Updates VirtualBox builders using "guest_additions_attach"
-                      to use "guest_additions_mode"
-  pp-vagrant-override Replaces old-style provider overrides for the Vagrant
-                      post-processor to new-style as of Packer 0.5.0.
-  virtualbox-rename   Updates "virtualbox" builders to "virtualbox-iso"
-
-`
diff --git a/command/inspect/command.go b/command/inspect.go
similarity index 82%
rename from command/inspect/command.go
rename to command/inspect.go
index 25d8427cc..8a9fd9569 100644
--- a/command/inspect/command.go
+++ b/command/inspect.go
@@ -1,4 +1,4 @@
-package inspect
+package command
 
 import (
 	"flag"
@@ -9,17 +9,17 @@ import (
 	"strings"
 )
 
-type Command struct{}
-
-func (Command) Help() string {
-	return strings.TrimSpace(helpText)
+type InspectCommand struct{
+	Meta
 }
 
-func (c Command) Synopsis() string {
-	return "see components of a template"
-}
+func (c *InspectCommand) Run(args []string) int {
+	env, err := c.Meta.Environment()
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Error initializing environment: %s", err))
+		return 1
+	}
 
-func (c Command) Run(env packer.Environment, args []string) int {
 	flags := flag.NewFlagSet("inspect", flag.ContinueOnError)
 	flags.Usage = func() { env.Ui().Say(c.Help()) }
 	if err := flags.Parse(args); err != nil {
@@ -148,3 +148,23 @@ func (c Command) Run(env packer.Environment, args []string) int {
 
 	return 0
 }
+
+func (*InspectCommand) Help() string {
+	helpText := `
+Usage: packer inspect TEMPLATE
+
+  Inspects a template, parsing and outputting the components a template
+  defines. This does not validate the contents of a template (other than
+  basic syntax by necessity).
+
+Options:
+
+  -machine-readable  Machine-readable output
+`
+
+	return strings.TrimSpace(helpText)
+}
+
+func (c *InspectCommand) Synopsis() string {
+	return "see components of a template"
+}
diff --git a/command/inspect/command_test.go b/command/inspect/command_test.go
deleted file mode 100644
index a2766fef4..000000000
--- a/command/inspect/command_test.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package inspect
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestCommand_Impl(t *testing.T) {
-	var raw interface{}
-	raw = new(Command)
-	if _, ok := raw.(packer.Command); !ok {
-		t.Fatalf("must be a Command")
-	}
-}
diff --git a/command/inspect/help.go b/command/inspect/help.go
deleted file mode 100644
index 320f24e8f..000000000
--- a/command/inspect/help.go
+++ /dev/null
@@ -1,13 +0,0 @@
-package inspect
-
-const helpText = `
-Usage: packer inspect TEMPLATE
-
-  Inspects a template, parsing and outputting the components a template
-  defines. This does not validate the contents of a template (other than
-  basic syntax by necessity).
-
-Options:
-
-  -machine-readable  Machine-readable output
-`
diff --git a/command/meta.go b/command/meta.go
new file mode 100644
index 000000000..9c2f7f921
--- /dev/null
+++ b/command/meta.go
@@ -0,0 +1,15 @@
+package command
+
+import (
+	"github.com/mitchellh/cli"
+	"github.com/mitchellh/packer/packer"
+)
+
+type Meta struct {
+	EnvConfig *packer.EnvironmentConfig
+	Ui        cli.Ui
+}
+
+func (m *Meta) Environment() (packer.Environment, error) {
+	return packer.NewEnvironment(m.EnvConfig)
+}
diff --git a/command/validate/command.go b/command/validate.go
similarity index 72%
rename from command/validate/command.go
rename to command/validate.go
index 838ba13b5..a63019a9c 100644
--- a/command/validate/command.go
+++ b/command/validate.go
@@ -1,4 +1,4 @@
-package validate
+package command
 
 import (
 	"flag"
@@ -9,16 +9,20 @@ import (
 	"strings"
 )
 
-type Command byte
-
-func (Command) Help() string {
-	return strings.TrimSpace(helpString)
+type ValidateCommand struct {
+	Meta
 }
 
-func (c Command) Run(env packer.Environment, args []string) int {
+func (c *ValidateCommand) Run(args []string) int {
 	var cfgSyntaxOnly bool
 	buildOptions := new(cmdcommon.BuildOptions)
 
+	env, err := c.Meta.Environment()
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Error initializing environment: %s", err))
+		return 1
+	}
+
 	cmdFlags := flag.NewFlagSet("validate", flag.ContinueOnError)
 	cmdFlags.Usage = func() { env.Ui().Say(c.Help()) }
 	cmdFlags.BoolVar(&cfgSyntaxOnly, "syntax-only", false, "check syntax only")
@@ -123,6 +127,29 @@ func (c Command) Run(env packer.Environment, args []string) int {
 	return 0
 }
 
-func (Command) Synopsis() string {
+func (*ValidateCommand) Help() string {
+	helpText := `
+Usage: packer validate [options] TEMPLATE
+
+  Checks the template is valid by parsing the template and also
+  checking the configuration with the various builders, provisioners, etc.
+
+  If it is not valid, the errors will be shown and the command will exit
+  with a non-zero exit status. If it is valid, it will exit with a zero
+  exit status.
+
+Options:
+
+  -syntax-only           Only check syntax. Do not verify config of the template.
+  -except=foo,bar,baz    Validate all builds other than these
+  -only=foo,bar,baz      Validate only these builds
+  -var 'key=value'       Variable for templates, can be used multiple times.
+  -var-file=path         JSON file containing user variables.
+`
+
+	return strings.TrimSpace(helpText)
+}
+
+func (*ValidateCommand) Synopsis() string {
 	return "check that a template is valid"
 }
diff --git a/command/validate/command_test.go b/command/validate/command_test.go
deleted file mode 100644
index 33fab19dd..000000000
--- a/command/validate/command_test.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package validate
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"testing"
-)
-
-func TestCommand_Impl(t *testing.T) {
-	var raw interface{}
-	raw = new(Command)
-	if _, ok := raw.(packer.Command); !ok {
-		t.Fatalf("must be a Command")
-	}
-}
diff --git a/command/validate/help.go b/command/validate/help.go
deleted file mode 100644
index 8959cd881..000000000
--- a/command/validate/help.go
+++ /dev/null
@@ -1,20 +0,0 @@
-package validate
-
-const helpString = `
-Usage: packer validate [options] TEMPLATE
-
-  Checks the template is valid by parsing the template and also
-  checking the configuration with the various builders, provisioners, etc.
-
-  If it is not valid, the errors will be shown and the command will exit
-  with a non-zero exit status. If it is valid, it will exit with a zero
-  exit status.
-
-Options:
-
-  -syntax-only           Only check syntax. Do not verify config of the template.
-  -except=foo,bar,baz    Validate all builds other than these
-  -only=foo,bar,baz      Validate only these builds
-  -var 'key=value'       Variable for templates, can be used multiple times.
-  -var-file=path         JSON file containing user variables.
-`
diff --git a/command/version.go b/command/version.go
new file mode 100644
index 000000000..689614e60
--- /dev/null
+++ b/command/version.go
@@ -0,0 +1,83 @@
+package command
+
+import (
+	"bytes"
+	"fmt"
+)
+
+// VersionCommand is a Command implementation prints the version.
+type VersionCommand struct {
+	Meta
+
+	Revision          string
+	Version           string
+	VersionPrerelease string
+	CheckFunc         VersionCheckFunc
+}
+
+// VersionCheckFunc is the callback called by the Version command to
+// check if there is a new version of Packer.
+type VersionCheckFunc func() (VersionCheckInfo, error)
+
+// VersionCheckInfo is the return value for the VersionCheckFunc callback
+// and tells the Version command information about the latest version
+// of Packer.
+type VersionCheckInfo struct {
+	Outdated bool
+	Latest   string
+	Alerts   []string
+}
+
+func (c *VersionCommand) Help() string {
+	return ""
+}
+
+func (c *VersionCommand) Run(args []string) int {
+	env, err := c.Meta.Environment()
+	if err != nil {
+		c.Ui.Error(fmt.Sprintf("Error initializing environment: %s", err))
+		return 1
+	}
+
+	env.Ui().Machine("version", c.Version)
+	env.Ui().Machine("version-prelease", c.VersionPrerelease)
+	env.Ui().Machine("version-commit", c.Revision)
+
+	var versionString bytes.Buffer
+	fmt.Fprintf(&versionString, "Packer v%s", c.Version)
+	if c.VersionPrerelease != "" {
+		fmt.Fprintf(&versionString, ".%s", c.VersionPrerelease)
+
+		if c.Revision != "" {
+			fmt.Fprintf(&versionString, " (%s)", c.Revision)
+		}
+	}
+
+	c.Ui.Output(versionString.String())
+
+	// If we have a version check function, then let's check for
+	// the latest version as well.
+	if c.CheckFunc != nil {
+		// Separate the prior output with a newline
+		c.Ui.Output("")
+
+		// Check the latest version
+		info, err := c.CheckFunc()
+		if err != nil {
+			c.Ui.Error(fmt.Sprintf(
+				"Error checking latest version: %s", err))
+		}
+		if info.Outdated {
+			c.Ui.Output(fmt.Sprintf(
+				"Your version of Packer is out of date! The latest version\n"+
+					"is %s. You can update by downloading from www.packer.io",
+				info.Latest))
+		}
+	}
+
+	return 0
+}
+
+func (c *VersionCommand) Synopsis() string {
+	return "Prints the Packer version"
+}
diff --git a/command/version_test.go b/command/version_test.go
new file mode 100644
index 000000000..2a645690f
--- /dev/null
+++ b/command/version_test.go
@@ -0,0 +1,11 @@
+package command
+
+import (
+	"testing"
+
+	"github.com/mitchellh/cli"
+)
+
+func TestVersionCommand_implements(t *testing.T) {
+	var _ cli.Command = &VersionCommand{}
+}
diff --git a/commands.go b/commands.go
new file mode 100644
index 000000000..193fd1465
--- /dev/null
+++ b/commands.go
@@ -0,0 +1,86 @@
+package main
+
+import (
+	"os"
+	"os/signal"
+
+	"github.com/mitchellh/cli"
+	"github.com/mitchellh/packer/command"
+)
+
+// Commands is the mapping of all the available Terraform commands.
+var Commands map[string]cli.CommandFactory
+
+// Ui is the cli.Ui used for communicating to the outside world.
+var Ui cli.Ui
+
+const ErrorPrefix = "e:"
+const OutputPrefix = "o:"
+
+func init() {
+	Ui = &cli.PrefixedUi{
+		AskPrefix:    OutputPrefix,
+		OutputPrefix: OutputPrefix,
+		InfoPrefix:   OutputPrefix,
+		ErrorPrefix:  ErrorPrefix,
+		Ui:           &cli.BasicUi{Writer: os.Stdout},
+	}
+
+	meta := command.Meta{
+		EnvConfig: &EnvConfig,
+		Ui:        Ui,
+	}
+
+	Commands = map[string]cli.CommandFactory{
+		"build": func() (cli.Command, error) {
+			return &command.BuildCommand{
+				Meta: meta,
+			}, nil
+		},
+
+		"fix": func() (cli.Command, error) {
+			return &command.FixCommand{
+				Meta: meta,
+			}, nil
+		},
+
+		"inspect": func() (cli.Command, error) {
+			return &command.InspectCommand{
+				Meta: meta,
+			}, nil
+		},
+
+		"validate": func() (cli.Command, error) {
+			return &command.ValidateCommand{
+				Meta: meta,
+			}, nil
+		},
+
+		"version": func() (cli.Command, error) {
+			return &command.VersionCommand{
+				Meta:              meta,
+				Revision:          GitCommit,
+				Version:           Version,
+				VersionPrerelease: VersionPrerelease,
+				CheckFunc:         commandVersionCheck,
+			}, nil
+		},
+	}
+}
+
+// makeShutdownCh creates an interrupt listener and returns a channel.
+// A message will be sent on the channel for every interrupt received.
+func makeShutdownCh() <-chan struct{} {
+	resultCh := make(chan struct{})
+
+	signalCh := make(chan os.Signal, 4)
+	signal.Notify(signalCh, os.Interrupt)
+	go func() {
+		for {
+			<-signalCh
+			resultCh <- struct{}{}
+		}
+	}()
+
+	return resultCh
+}
diff --git a/common/config.go b/common/config.go
index 4c6fbbbef..4a56cc356 100644
--- a/common/config.go
+++ b/common/config.go
@@ -68,7 +68,7 @@ func DecodeConfig(target interface{}, raws ...interface{}) (*mapstructure.Metada
 
 	var md mapstructure.Metadata
 	decoderConfig := &mapstructure.DecoderConfig{
-		DecodeHook:       mapstructure.ComposeDecodeHookFunc(
+		DecodeHook: mapstructure.ComposeDecodeHookFunc(
 			decodeHook,
 			mapstructure.StringToSliceHookFunc(","),
 		),
@@ -217,6 +217,18 @@ func decodeConfigHook(raws []interface{}) (mapstructure.DecodeHookFunc, error) {
 
 	return func(f reflect.Kind, t reflect.Kind, v interface{}) (interface{}, error) {
 		if t != reflect.String {
+			// We need to convert []uint8 to string. We have to do this
+			// because internally Packer uses MsgPack for RPC and the MsgPack
+			// codec turns strings into []uint8
+			if f == reflect.Slice {
+				dataVal := reflect.ValueOf(v)
+				dataType := dataVal.Type()
+				elemKind := dataType.Elem().Kind()
+				if elemKind == reflect.Uint8 {
+					v = string(dataVal.Interface().([]uint8))
+				}
+			}
+
 			if sv, ok := v.(string); ok {
 				var err error
 				v, err = tpl.Process(sv, nil)
diff --git a/common/config_test.go b/common/config_test.go
index 3217a2ebd..a93feb729 100644
--- a/common/config_test.go
+++ b/common/config_test.go
@@ -99,7 +99,8 @@ func TestDecodeConfig(t *testing.T) {
 // configuration.
 func TestDecodeConfig_stringToSlice(t *testing.T) {
 	type Local struct {
-		Val []string
+		Val      []string
+		EmptyVal []string
 	}
 
 	raw := map[string]interface{}{
@@ -107,7 +108,8 @@ func TestDecodeConfig_stringToSlice(t *testing.T) {
 			"foo": "bar",
 		},
 
-		"val": "foo,{{user `foo`}}",
+		"val":      "foo,{{user `foo`}}",
+		"emptyval": "",
 	}
 
 	var result Local
@@ -120,6 +122,9 @@ func TestDecodeConfig_stringToSlice(t *testing.T) {
 	if !reflect.DeepEqual(result.Val, expected) {
 		t.Fatalf("invalid: %#v", result.Val)
 	}
+	if len(result.EmptyVal) > 0 {
+		t.Fatalf("invalid: %#v", result.EmptyVal)
+	}
 }
 
 // This test tests the case that a user var is used for an integer
@@ -148,6 +153,32 @@ func TestDecodeConfig_userVarConversion(t *testing.T) {
 	}
 }
 
+// This tests the way MessagePack decodes strings (into []uint8) and
+// that we can still decode into the proper types.
+func TestDecodeConfig_userVarConversionUInt8(t *testing.T) {
+	type Local struct {
+		Val int
+	}
+
+	raw := map[string]interface{}{
+		"packer_user_variables": map[string]string{
+			"foo": "42",
+		},
+
+		"val": []uint8("{{user `foo`}}"),
+	}
+
+	var result Local
+	_, err := DecodeConfig(&result, raw)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if result.Val != 42 {
+		t.Fatalf("invalid: %#v", result.Val)
+	}
+}
+
 func TestDownloadableURL(t *testing.T) {
 	// Invalid URL: has hex code in host
 	_, err := DownloadableURL("http://what%20.com")
diff --git a/common/ssh/key.go b/common/ssh/key.go
new file mode 100644
index 000000000..11a4b0742
--- /dev/null
+++ b/common/ssh/key.go
@@ -0,0 +1,44 @@
+package ssh
+
+import (
+	"encoding/pem"
+	"fmt"
+	"io/ioutil"
+	"os"
+
+	"code.google.com/p/go.crypto/ssh"
+)
+
+// FileSigner returns an ssh.Signer for a key file.
+func FileSigner(path string) (ssh.Signer, error) {
+	f, err := os.Open(path)
+	if err != nil {
+		return nil, err
+	}
+	defer f.Close()
+
+	keyBytes, err := ioutil.ReadAll(f)
+	if err != nil {
+		return nil, err
+	}
+
+	// We parse the private key on our own first so that we can
+	// show a nicer error if the private key has a password.
+	block, _ := pem.Decode(keyBytes)
+	if block == nil {
+		return nil, fmt.Errorf(
+			"Failed to read key '%s': no key found", path)
+	}
+	if block.Headers["Proc-Type"] == "4,ENCRYPTED" {
+		return nil, fmt.Errorf(
+			"Failed to read key '%s': password protected keys are\n"+
+				"not supported. Please decrypt the key prior to use.", path)
+	}
+
+	signer, err := ssh.ParsePrivateKey(keyBytes)
+	if err != nil {
+		return nil, fmt.Errorf("Error setting up SSH config: %s", err)
+	}
+
+	return signer, nil
+}
diff --git a/common/step_connect_ssh.go b/common/step_connect_ssh.go
index fa2f7d64f..b00d5bfc0 100644
--- a/common/step_connect_ssh.go
+++ b/common/step_connect_ssh.go
@@ -98,13 +98,18 @@ func (s *StepConnectSSH) waitForSSH(state multistep.StateBag, cancel <-chan stru
 	handshakeAttempts := 0
 
 	var comm packer.Communicator
+	first := true
 	for {
-		select {
-		case <-cancel:
-			log.Println("SSH wait cancelled. Exiting loop.")
-			return nil, errors.New("SSH wait cancelled")
-		case <-time.After(5 * time.Second):
+		// Don't check for cancel or wait on first iteration
+		if !first {
+			select {
+			case <-cancel:
+				log.Println("SSH wait cancelled. Exiting loop.")
+				return nil, errors.New("SSH wait cancelled")
+			case <-time.After(5 * time.Second):
+			}
 		}
+		first = false
 
 		// First we request the TCP connection information
 		address, err := s.SSHAddress(state)
diff --git a/common/step_create_floppy.go b/common/step_create_floppy.go
index 0f4e2939c..7b9b8c537 100644
--- a/common/step_create_floppy.go
+++ b/common/step_create_floppy.go
@@ -11,6 +11,7 @@ import (
 	"log"
 	"os"
 	"path/filepath"
+	"strings"
 )
 
 // StepCreateFloppy will create a floppy disk with the given files.
@@ -20,6 +21,8 @@ type StepCreateFloppy struct {
 	Files []string
 
 	floppyPath string
+
+	FilesAdded map[string]bool
 }
 
 func (s *StepCreateFloppy) Run(state multistep.StateBag) multistep.StepAction {
@@ -28,6 +31,8 @@ func (s *StepCreateFloppy) Run(state multistep.StateBag) multistep.StepAction {
 		return multistep.ActionContinue
 	}
 
+	s.FilesAdded = make(map[string]bool)
+
 	ui := state.Get("ui").(packer.Ui)
 	ui.Say("Creating floppy disk...")
 
@@ -43,7 +48,7 @@ func (s *StepCreateFloppy) Run(state multistep.StateBag) multistep.StepAction {
 	// Set the path so we can remove it later
 	s.floppyPath = floppyF.Name()
 
-	log.Printf("Floppy path: %s", floppyF.Name())
+	log.Printf("Floppy path: %s", s.floppyPath)
 
 	// Set the size of the file to be a floppy sized
 	if err := floppyF.Truncate(1440 * 1024); err != nil {
@@ -89,8 +94,8 @@ func (s *StepCreateFloppy) Run(state multistep.StateBag) multistep.StepAction {
 
 	// Go over each file and copy it.
 	for _, filename := range s.Files {
-		ui.Message(fmt.Sprintf("Copying: %s", filepath.Base(filename)))
-		if err := s.addSingleFile(rootDir, filename); err != nil {
+		ui.Message(fmt.Sprintf("Copying: %s", filename))
+		if err := s.addFilespec(rootDir, filename); err != nil {
 			state.Put("error", fmt.Errorf("Error adding file to floppy: %s", err))
 			return multistep.ActionHalt
 		}
@@ -109,6 +114,61 @@ func (s *StepCreateFloppy) Cleanup(multistep.StateBag) {
 	}
 }
 
+func (s *StepCreateFloppy) addFilespec(dir fs.Directory, src string) error {
+	// same as http://golang.org/src/pkg/path/filepath/match.go#L308
+	if strings.IndexAny(src, "*?[") >= 0 {
+		matches, err := filepath.Glob(src)
+		if err != nil {
+			return err
+		}
+		return s.addFiles(dir, matches)
+	}
+
+	finfo, err := os.Stat(src)
+	if err != nil {
+		return err
+	}
+
+	if finfo.IsDir() {
+		return s.addDirectory(dir, src)
+	}
+
+	return s.addSingleFile(dir, src)
+}
+
+func (s *StepCreateFloppy) addFiles(dir fs.Directory, files []string) error {
+	for _, file := range files {
+		err := s.addFilespec(dir, file)
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func (s *StepCreateFloppy) addDirectory(dir fs.Directory, src string) error {
+	log.Printf("Adding directory to floppy: %s", src)
+
+	walkFn := func(path string, finfo os.FileInfo, err error) error {
+		if err != nil {
+			return err
+		}
+
+		if path == src {
+			return nil
+		}
+
+		if finfo.IsDir() {
+			return s.addDirectory(dir, path)
+		}
+
+		return s.addSingleFile(dir, path)
+	}
+
+	return filepath.Walk(src, walkFn)
+}
+
 func (s *StepCreateFloppy) addSingleFile(dir fs.Directory, src string) error {
 	log.Printf("Adding file to floppy: %s", src)
 
@@ -132,5 +192,7 @@ func (s *StepCreateFloppy) addSingleFile(dir fs.Directory, src string) error {
 		return err
 	}
 
+	s.FilesAdded[src] = true
+
 	return nil
 }
diff --git a/common/step_create_floppy_test.go b/common/step_create_floppy_test.go
new file mode 100644
index 000000000..b6e591a41
--- /dev/null
+++ b/common/step_create_floppy_test.go
@@ -0,0 +1,193 @@
+package common
+
+import (
+	"bytes"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"io/ioutil"
+	"os"
+	"path"
+	"strconv"
+	"testing"
+)
+
+func TestStepCreateFloppy_Impl(t *testing.T) {
+	var raw interface{}
+	raw = new(StepCreateFloppy)
+	if _, ok := raw.(multistep.Step); !ok {
+		t.Fatalf("StepCreateFloppy should be a step")
+	}
+}
+
+func testStepCreateFloppyState(t *testing.T) multistep.StateBag {
+	state := new(multistep.BasicStateBag)
+	state.Put("ui", &packer.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	})
+	return state
+}
+
+func TestStepCreateFloppy(t *testing.T) {
+	state := testStepCreateFloppyState(t)
+	step := new(StepCreateFloppy)
+
+	dir, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.RemoveAll(dir)
+
+	count := 10
+	expected := count
+	files := make([]string, count)
+
+	prefix := "exists"
+	ext := ".tmp"
+
+	for i := 0; i < expected; i++ {
+		files[i] = path.Join(dir, prefix+strconv.Itoa(i)+ext)
+
+		_, err := os.Create(files[i])
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+	}
+
+	lists := [][]string{
+		files,
+		[]string{dir + string(os.PathSeparator) + prefix + "*" + ext},
+		[]string{dir + string(os.PathSeparator) + prefix + "?" + ext},
+		[]string{dir + string(os.PathSeparator) + prefix + "[0123456789]" + ext},
+		[]string{dir + string(os.PathSeparator) + prefix + "[0-9]" + ext},
+		[]string{dir + string(os.PathSeparator)},
+		[]string{dir},
+	}
+
+	for _, step.Files = range lists {
+		if action := step.Run(state); action != multistep.ActionContinue {
+			t.Fatalf("bad action: %#v for %v", action, step.Files)
+		}
+
+		if _, ok := state.GetOk("error"); ok {
+			t.Fatalf("state should be ok for %v", step.Files)
+		}
+
+		floppy_path := state.Get("floppy_path").(string)
+
+		if _, err := os.Stat(floppy_path); err != nil {
+			t.Fatal("file not found: %s for %v", floppy_path, step.Files)
+		}
+
+		if len(step.FilesAdded) != expected {
+			t.Fatalf("expected %d, found %d for %v", expected, len(step.FilesAdded), step.Files)
+		}
+
+		step.Cleanup(state)
+
+		if _, err := os.Stat(floppy_path); err == nil {
+			t.Fatal("file found: %s for %v", floppy_path, step.Files)
+		}
+	}
+}
+
+func xxxTestStepCreateFloppy_missing(t *testing.T) {
+	state := testStepCreateFloppyState(t)
+	step := new(StepCreateFloppy)
+
+	dir, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.RemoveAll(dir)
+
+	count := 2
+	expected := 0
+	files := make([]string, count)
+
+	prefix := "missing"
+
+	for i := 0; i < count; i++ {
+		files[i] = path.Join(dir, prefix+strconv.Itoa(i))
+	}
+
+	lists := [][]string{
+		files,
+	}
+
+	for _, step.Files = range lists {
+		if action := step.Run(state); action != multistep.ActionHalt {
+			t.Fatalf("bad action: %#v for %v", action, step.Files)
+		}
+
+		if _, ok := state.GetOk("error"); !ok {
+			t.Fatalf("state should not be ok for %v", step.Files)
+		}
+
+		floppy_path := state.Get("floppy_path")
+
+		if floppy_path != nil {
+			t.Fatalf("floppy_path is not nil for %v", step.Files)
+		}
+
+		if len(step.FilesAdded) != expected {
+			t.Fatalf("expected %d, found %d for %v", expected, len(step.FilesAdded), step.Files)
+		}
+	}
+}
+
+func xxxTestStepCreateFloppy_notfound(t *testing.T) {
+	state := testStepCreateFloppyState(t)
+	step := new(StepCreateFloppy)
+
+	dir, err := ioutil.TempDir("", "packer")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	defer os.RemoveAll(dir)
+
+	count := 2
+	expected := 0
+	files := make([]string, count)
+
+	prefix := "notfound"
+
+	for i := 0; i < count; i++ {
+		files[i] = path.Join(dir, prefix+strconv.Itoa(i))
+	}
+
+	lists := [][]string{
+		[]string{dir + string(os.PathSeparator) + prefix + "*"},
+		[]string{dir + string(os.PathSeparator) + prefix + "?"},
+		[]string{dir + string(os.PathSeparator) + prefix + "[0123456789]"},
+		[]string{dir + string(os.PathSeparator) + prefix + "[0-9]"},
+		[]string{dir + string(os.PathSeparator)},
+		[]string{dir},
+	}
+
+	for _, step.Files = range lists {
+		if action := step.Run(state); action != multistep.ActionContinue {
+			t.Fatalf("bad action: %#v for %v", action, step.Files)
+		}
+
+		if _, ok := state.GetOk("error"); ok {
+			t.Fatalf("state should be ok for %v", step.Files)
+		}
+
+		floppy_path := state.Get("floppy_path").(string)
+
+		if _, err := os.Stat(floppy_path); err != nil {
+			t.Fatal("file not found: %s for %v", floppy_path, step.Files)
+		}
+
+		if len(step.FilesAdded) != expected {
+			t.Fatalf("expected %d, found %d for %v", expected, len(step.FilesAdded), step.Files)
+		}
+
+		step.Cleanup(state)
+
+		if _, err := os.Stat(floppy_path); err == nil {
+			t.Fatal("file found: %s for %v", floppy_path, step.Files)
+		}
+	}
+}
diff --git a/common/step_download.go b/common/step_download.go
index 34156d52d..8d6378adc 100644
--- a/common/step_download.go
+++ b/common/step_download.go
@@ -3,10 +3,11 @@ package common
 import (
 	"encoding/hex"
 	"fmt"
-	"github.com/mitchellh/multistep"
-	"github.com/mitchellh/packer/packer"
 	"log"
 	"time"
+
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
 )
 
 // StepDownload downloads a remote file using the download client within
@@ -70,7 +71,7 @@ func (s *StepDownload) Run(state multistep.StateBag) multistep.StepAction {
 			CopyFile:   false,
 			Hash:       HashForType(s.ChecksumType),
 			Checksum:   checksum,
-			UserAgent:  packer.VersionString(),
+			UserAgent:  "Packer",
 		}
 
 		path, err, retry := s.download(config, state)
diff --git a/communicator/ssh/communicator.go b/communicator/ssh/communicator.go
index e07f875c6..245f3ceb0 100644
--- a/communicator/ssh/communicator.go
+++ b/communicator/ssh/communicator.go
@@ -119,7 +119,7 @@ func (c *comm) Start(cmd *packer.RemoteCmd) (err error) {
 	return
 }
 
-func (c *comm) Upload(path string, input io.Reader) error {
+func (c *comm) Upload(path string, input io.Reader, fi *os.FileInfo) error {
 	// The target directory and file for talking the SCP protocol
 	target_dir := filepath.Dir(path)
 	target_file := filepath.Base(path)
@@ -130,7 +130,7 @@ func (c *comm) Upload(path string, input io.Reader) error {
 	target_dir = filepath.ToSlash(target_dir)
 
 	scpFunc := func(w io.Writer, stdoutR *bufio.Reader) error {
-		return scpUploadFile(target_file, input, w, stdoutR)
+		return scpUploadFile(target_file, input, w, stdoutR, fi)
 	}
 
 	return c.scpSession("scp -vt "+target_dir, scpFunc)
@@ -156,7 +156,11 @@ func (c *comm) UploadDir(dst string, src string, excl []string) error {
 
 		if src[len(src)-1] != '/' {
 			log.Printf("No trailing slash, creating the source directory name")
-			return scpUploadDirProtocol(filepath.Base(src), w, r, uploadEntries)
+			fi, err := os.Stat(src)
+			if err != nil {
+				return err
+			}
+			return scpUploadDirProtocol(filepath.Base(src), w, r, uploadEntries, fi)
 		} else {
 			// Trailing slash, so only upload the contents
 			return uploadEntries()
@@ -328,45 +332,60 @@ func checkSCPStatus(r *bufio.Reader) error {
 	return nil
 }
 
-func scpUploadFile(dst string, src io.Reader, w io.Writer, r *bufio.Reader) error {
-	// Create a temporary file where we can copy the contents of the src
-	// so that we can determine the length, since SCP is length-prefixed.
-	tf, err := ioutil.TempFile("", "packer-upload")
-	if err != nil {
-		return fmt.Errorf("Error creating temporary file for upload: %s", err)
-	}
-	defer os.Remove(tf.Name())
-	defer tf.Close()
+func scpUploadFile(dst string, src io.Reader, w io.Writer, r *bufio.Reader, fi *os.FileInfo) error {
+	var mode os.FileMode
+	var size int64
 
-	log.Println("Copying input data into temporary file so we can read the length")
-	if _, err := io.Copy(tf, src); err != nil {
-		return err
-	}
+	if fi != nil {
+		mode = (*fi).Mode().Perm()
+		size = (*fi).Size()
+	} else {
+		// Create a temporary file where we can copy the contents of the src
+		// so that we can determine the length, since SCP is length-prefixed.
+		tf, err := ioutil.TempFile("", "packer-upload")
+		if err != nil {
+			return fmt.Errorf("Error creating temporary file for upload: %s", err)
+		}
+		defer os.Remove(tf.Name())
+		defer tf.Close()
 
-	// Sync the file so that the contents are definitely on disk, then
-	// read the length of it.
-	if err := tf.Sync(); err != nil {
-		return fmt.Errorf("Error creating temporary file for upload: %s", err)
-	}
+		mode = 0644
 
-	// Seek the file to the beginning so we can re-read all of it
-	if _, err := tf.Seek(0, 0); err != nil {
-		return fmt.Errorf("Error creating temporary file for upload: %s", err)
-	}
+		log.Println("Copying input data into temporary file so we can read the length")
+		if _, err := io.Copy(tf, src); err != nil {
+			return err
+		}
 
-	fi, err := tf.Stat()
-	if err != nil {
-		return fmt.Errorf("Error creating temporary file for upload: %s", err)
+		// Sync the file so that the contents are definitely on disk, then
+		// read the length of it.
+		if err := tf.Sync(); err != nil {
+			return fmt.Errorf("Error creating temporary file for upload: %s", err)
+		}
+
+		// Seek the file to the beginning so we can re-read all of it
+		if _, err := tf.Seek(0, 0); err != nil {
+			return fmt.Errorf("Error creating temporary file for upload: %s", err)
+		}
+
+		tfi, err := tf.Stat()
+		if err != nil {
+			return fmt.Errorf("Error creating temporary file for upload: %s", err)
+		}
+
+		size = tfi.Size()
+		src = tf
 	}
 
 	// Start the protocol
-	log.Println("Beginning file upload...")
-	fmt.Fprintln(w, "C0644", fi.Size(), dst)
+	perms := fmt.Sprintf("C%04o", mode)
+	log.Printf("[DEBUG] Uploading %s: perms=%s size=%d", dst, perms, size)
+
+	fmt.Fprintln(w, perms, size, dst)
 	if err := checkSCPStatus(r); err != nil {
 		return err
 	}
 
-	if _, err := io.Copy(w, tf); err != nil {
+	if _, err := io.CopyN(w, src, size); err != nil {
 		return err
 	}
 
@@ -378,9 +397,14 @@ func scpUploadFile(dst string, src io.Reader, w io.Writer, r *bufio.Reader) erro
 	return nil
 }
 
-func scpUploadDirProtocol(name string, w io.Writer, r *bufio.Reader, f func() error) error {
+func scpUploadDirProtocol(name string, w io.Writer, r *bufio.Reader, f func() error, fi os.FileInfo) error {
 	log.Printf("SCP: starting directory upload: %s", name)
-	fmt.Fprintln(w, "D0755 0", name)
+
+	mode := fi.Mode().Perm()
+
+	perms := fmt.Sprintf("D%04o 0", mode)
+
+	fmt.Fprintln(w, perms, name)
 	err := checkSCPStatus(r)
 	if err != nil {
 		return err
@@ -430,7 +454,7 @@ func scpUploadDir(root string, fs []os.FileInfo, w io.Writer, r *bufio.Reader) e
 
 			err = func() error {
 				defer f.Close()
-				return scpUploadFile(fi.Name(), f, w, r)
+				return scpUploadFile(fi.Name(), f, w, r, &fi)
 			}()
 
 			if err != nil {
@@ -454,7 +478,7 @@ func scpUploadDir(root string, fs []os.FileInfo, w io.Writer, r *bufio.Reader) e
 			}
 
 			return scpUploadDir(realPath, entries, w, r)
-		})
+		}, fi)
 		if err != nil {
 			return err
 		}
diff --git a/communicator/ssh/connect.go b/communicator/ssh/connect.go
index 1a01e024c..b280f3ead 100644
--- a/communicator/ssh/connect.go
+++ b/communicator/ssh/connect.go
@@ -17,6 +17,7 @@ func ConnectFunc(network, addr string) func() (net.Conn, error) {
 
 		if tcpConn, ok := c.(*net.TCPConn); ok {
 			tcpConn.SetKeepAlive(true)
+			tcpConn.SetKeepAlivePeriod(5 * time.Second)
 		}
 
 		return c, nil
diff --git a/config.go b/config.go
index 1a58a0862..091dce2c2 100644
--- a/config.go
+++ b/config.go
@@ -2,75 +2,44 @@ package main
 
 import (
 	"encoding/json"
-	"github.com/mitchellh/osext"
-	"github.com/mitchellh/packer/packer"
-	"github.com/mitchellh/packer/packer/plugin"
 	"io"
 	"log"
 	"os/exec"
 	"path/filepath"
+	"strings"
+
+	"github.com/mitchellh/osext"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/packer/plugin"
 )
 
-// This is the default, built-in configuration that ships with
-// Packer.
-const defaultConfig = `
-{
-	"plugin_min_port": 10000,
-	"plugin_max_port": 25000,
-
-	"builders": {
-		"amazon-ebs": "packer-builder-amazon-ebs",
-		"amazon-chroot": "packer-builder-amazon-chroot",
-		"amazon-instance": "packer-builder-amazon-instance",
-		"digitalocean": "packer-builder-digitalocean",
-		"docker": "packer-builder-docker",
-		"googlecompute": "packer-builder-googlecompute",
-		"openstack": "packer-builder-openstack",
-		"qemu": "packer-builder-qemu",
-		"virtualbox-iso": "packer-builder-virtualbox-iso",
-		"virtualbox-ovf": "packer-builder-virtualbox-ovf",
-		"vmware-iso": "packer-builder-vmware-iso",
-		"vmware-vmx": "packer-builder-vmware-vmx",
-		"null": "packer-builder-null"
-	},
-
-	"commands": {
-		"build": "packer-command-build",
-		"fix": "packer-command-fix",
-		"inspect": "packer-command-inspect",
-		"validate": "packer-command-validate"
-	},
-
-	"post-processors": {
-		"vagrant": "packer-post-processor-vagrant",
-		"vsphere": "packer-post-processor-vsphere",
-		"docker-push": "packer-post-processor-docker-push",
-		"docker-import": "packer-post-processor-docker-import"
-	},
-
-	"provisioners": {
-		"ansible-local": "packer-provisioner-ansible-local",
-		"chef-client": "packer-provisioner-chef-client",
-		"chef-solo": "packer-provisioner-chef-solo",
-		"file": "packer-provisioner-file",
-		"puppet-masterless": "packer-provisioner-puppet-masterless",
-		"puppet-server": "packer-provisioner-puppet-server",
-		"shell": "packer-provisioner-shell",
-		"salt-masterless": "packer-provisioner-salt-masterless"
-	}
-}
-`
+// EnvConfig is the global EnvironmentConfig we use to initialize the CLI.
+var EnvConfig packer.EnvironmentConfig
 
 type config struct {
-	PluginMinPort uint
-	PluginMaxPort uint
+	DisableCheckpoint          bool `json:"disable_checkpoint"`
+	DisableCheckpointSignature bool `json:"disable_checkpoint_signature"`
+	PluginMinPort              uint
+	PluginMaxPort              uint
 
 	Builders       map[string]string
-	Commands       map[string]string
 	PostProcessors map[string]string `json:"post-processors"`
 	Provisioners   map[string]string
 }
 
+// ConfigFile returns the default path to the configuration file. On
+// Unix-like systems this is the ".packerconfig" file in the home directory.
+// On Windows, this is the "packer.config" file in the application data
+// directory.
+func ConfigFile() (string, error) {
+	return configFile()
+}
+
+// ConfigDir returns the configuration directory for Packer.
+func ConfigDir() (string, error) {
+	return configDir()
+}
+
 // Decodes configuration in JSON format from the given io.Reader into
 // the config object pointed to.
 func decodeConfig(r io.Reader, c *config) error {
@@ -78,13 +47,38 @@ func decodeConfig(r io.Reader, c *config) error {
 	return decoder.Decode(c)
 }
 
-// Returns an array of defined command names.
-func (c *config) CommandNames() (result []string) {
-	result = make([]string, 0, len(c.Commands))
-	for name := range c.Commands {
-		result = append(result, name)
+// Discover discovers plugins.
+//
+// This looks in the directory of the executable and the CWD, in that
+// order for priority.
+func (c *config) Discover() error {
+	// Next, look in the same directory as the executable. Any conflicts
+	// will overwrite those found in our current directory.
+	exePath, err := osext.Executable()
+	if err != nil {
+		log.Printf("[ERR] Error loading exe directory: %s", err)
+	} else {
+		if err := c.discover(filepath.Dir(exePath)); err != nil {
+			return err
+		}
 	}
-	return
+
+	// Look in the plugins directory
+	dir, err := ConfigDir()
+	if err != nil {
+		log.Printf("[ERR] Error loading config directory: %s", err)
+	} else {
+		if err := c.discover(filepath.Join(dir, "plugins")); err != nil {
+			return err
+		}
+	}
+
+	// Look in the cwd.
+	if err := c.discover("."); err != nil {
+		return err
+	}
+
+	return nil
 }
 
 // This is a proper packer.BuilderFunc that can be used to load packer.Builder
@@ -100,19 +94,6 @@ func (c *config) LoadBuilder(name string) (packer.Builder, error) {
 	return c.pluginClient(bin).Builder()
 }
 
-// This is a proper packer.CommandFunc that can be used to load packer.Command
-// implementations from the defined plugins.
-func (c *config) LoadCommand(name string) (packer.Command, error) {
-	log.Printf("Loading command: %s\n", name)
-	bin, ok := c.Commands[name]
-	if !ok {
-		log.Printf("Command not found: %s\n", name)
-		return nil, nil
-	}
-
-	return c.pluginClient(bin).Command()
-}
-
 // This is a proper implementation of packer.HookFunc that can be used
 // to load packer.Hook implementations from the defined plugins.
 func (c *config) LoadHook(name string) (packer.Hook, error) {
@@ -146,6 +127,66 @@ func (c *config) LoadProvisioner(name string) (packer.Provisioner, error) {
 	return c.pluginClient(bin).Provisioner()
 }
 
+func (c *config) discover(path string) error {
+	var err error
+
+	if !filepath.IsAbs(path) {
+		path, err = filepath.Abs(path)
+		if err != nil {
+			return err
+		}
+	}
+
+	err = c.discoverSingle(
+		filepath.Join(path, "packer-builder-*"), &c.Builders)
+	if err != nil {
+		return err
+	}
+
+	err = c.discoverSingle(
+		filepath.Join(path, "packer-post-processor-*"), &c.PostProcessors)
+	if err != nil {
+		return err
+	}
+
+	err = c.discoverSingle(
+		filepath.Join(path, "packer-provisioner-*"), &c.Provisioners)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (c *config) discoverSingle(glob string, m *map[string]string) error {
+	matches, err := filepath.Glob(glob)
+	if err != nil {
+		return err
+	}
+
+	if *m == nil {
+		*m = make(map[string]string)
+	}
+
+	prefix := filepath.Base(glob)
+	prefix = prefix[:strings.Index(prefix, "*")]
+	for _, match := range matches {
+		file := filepath.Base(match)
+
+		// If the filename has a ".", trim up to there
+		if idx := strings.Index(file, "."); idx >= 0 {
+			file = file[:idx]
+		}
+
+		// Look for foo-bar-baz. The plugin name is "baz"
+		plugin := file[len(prefix):]
+		log.Printf("[DEBUG] Discoverd plugin: %s = %s", plugin, match)
+		(*m)[plugin] = match
+	}
+
+	return nil
+}
+
 func (c *config) pluginClient(path string) *plugin.Client {
 	originalPath := path
 
diff --git a/configfile_unix.go b/config_unix.go
similarity index 82%
rename from configfile_unix.go
rename to config_unix.go
index b0b28109f..2c8a7a304 100644
--- a/configfile_unix.go
+++ b/config_unix.go
@@ -13,7 +13,7 @@ import (
 )
 
 func configFile() (string, error) {
-	dir, err := configDir()
+	dir, err := homeDir()
 	if err != nil {
 		return "", err
 	}
@@ -22,6 +22,15 @@ func configFile() (string, error) {
 }
 
 func configDir() (string, error) {
+	dir, err := homeDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dir, ".packer.d"), nil
+}
+
+func homeDir() (string, error) {
 	// First prefer the HOME environmental variable
 	if home := os.Getenv("HOME"); home != "" {
 		log.Printf("Detected home directory from env var: %s", home)
diff --git a/configfile_windows.go b/config_windows.go
similarity index 80%
rename from configfile_windows.go
rename to config_windows.go
index c59359dd9..fa3ab94b7 100644
--- a/configfile_windows.go
+++ b/config_windows.go
@@ -16,7 +16,7 @@ var (
 const CSIDL_APPDATA = 26
 
 func configFile() (string, error) {
-	dir, err := configDir()
+	dir, err := homeDir()
 	if err != nil {
 		return "", err
 	}
@@ -25,6 +25,15 @@ func configFile() (string, error) {
 }
 
 func configDir() (string, error) {
+	dir, err := homeDir()
+	if err != nil {
+		return "", err
+	}
+
+	return filepath.Join(dir, "packer.d"), nil
+}
+
+func homeDir() (string, error) {
 	b := make([]uint16, syscall.MAX_PATH)
 
 	// See: http://msdn.microsoft.com/en-us/library/windows/desktop/bb762181(v=vs.85).aspx
diff --git a/configfile.go b/configfile.go
deleted file mode 100644
index 8b0e8eff1..000000000
--- a/configfile.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package main
-
-// ConfigFile returns the default path to the configuration file. On
-// Unix-like systems this is the ".packerconfig" file in the home directory.
-// On Windows, this is the "packer.config" file in the application data
-// directory.
-func ConfigFile() (string, error) {
-	return configFile()
-}
diff --git a/command/fix/fixer.go b/fix/fixer.go
similarity index 100%
rename from command/fix/fixer.go
rename to fix/fixer.go
diff --git a/command/fix/fixer_createtime.go b/fix/fixer_createtime.go
similarity index 100%
rename from command/fix/fixer_createtime.go
rename to fix/fixer_createtime.go
diff --git a/command/fix/fixer_createtime_test.go b/fix/fixer_createtime_test.go
similarity index 100%
rename from command/fix/fixer_createtime_test.go
rename to fix/fixer_createtime_test.go
diff --git a/command/fix/fixer_iso_md5.go b/fix/fixer_iso_md5.go
similarity index 100%
rename from command/fix/fixer_iso_md5.go
rename to fix/fixer_iso_md5.go
diff --git a/command/fix/fixer_iso_md5_test.go b/fix/fixer_iso_md5_test.go
similarity index 100%
rename from command/fix/fixer_iso_md5_test.go
rename to fix/fixer_iso_md5_test.go
diff --git a/command/fix/fixer_pp_vagrant_override.go b/fix/fixer_pp_vagrant_override.go
similarity index 100%
rename from command/fix/fixer_pp_vagrant_override.go
rename to fix/fixer_pp_vagrant_override.go
diff --git a/command/fix/fixer_pp_vagrant_override_test.go b/fix/fixer_pp_vagrant_override_test.go
similarity index 100%
rename from command/fix/fixer_pp_vagrant_override_test.go
rename to fix/fixer_pp_vagrant_override_test.go
diff --git a/command/fix/fixer_virtualbox_gaattach.go b/fix/fixer_virtualbox_gaattach.go
similarity index 100%
rename from command/fix/fixer_virtualbox_gaattach.go
rename to fix/fixer_virtualbox_gaattach.go
diff --git a/command/fix/fixer_virtualbox_gaattach_test.go b/fix/fixer_virtualbox_gaattach_test.go
similarity index 100%
rename from command/fix/fixer_virtualbox_gaattach_test.go
rename to fix/fixer_virtualbox_gaattach_test.go
diff --git a/command/fix/fixer_virtualbox_rename.go b/fix/fixer_virtualbox_rename.go
similarity index 100%
rename from command/fix/fixer_virtualbox_rename.go
rename to fix/fixer_virtualbox_rename.go
diff --git a/command/fix/fixer_virtualbox_rename_test.go b/fix/fixer_virtualbox_rename_test.go
similarity index 100%
rename from command/fix/fixer_virtualbox_rename_test.go
rename to fix/fixer_virtualbox_rename_test.go
diff --git a/command/fix/fixer_vmware_rename.go b/fix/fixer_vmware_rename.go
similarity index 100%
rename from command/fix/fixer_vmware_rename.go
rename to fix/fixer_vmware_rename.go
diff --git a/command/fix/fixer_vmware_rename_test.go b/fix/fixer_vmware_rename_test.go
similarity index 100%
rename from command/fix/fixer_vmware_rename_test.go
rename to fix/fixer_vmware_rename_test.go
diff --git a/log.go b/log.go
new file mode 100644
index 000000000..ad3593c55
--- /dev/null
+++ b/log.go
@@ -0,0 +1,29 @@
+package main
+
+import (
+	"io"
+	"os"
+)
+
+// These are the environmental variables that determine if we log, and if
+// we log whether or not the log should go to a file.
+const EnvLog = "PACKER_LOG"          //Set to True
+const EnvLogFile = "PACKER_LOG_PATH" //Set to a file
+
+// logOutput determines where we should send logs (if anywhere).
+func logOutput() (logOutput io.Writer, err error) {
+	logOutput = nil
+	if os.Getenv(EnvLog) != "" {
+		logOutput = os.Stderr
+
+		if logPath := os.Getenv(EnvLogFile); logPath != "" {
+			var err error
+			logOutput, err = os.Create(logPath)
+			if err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return
+}
diff --git a/packer.go b/main.go
similarity index 52%
rename from packer.go
rename to main.go
index 0674e503b..093719b3f 100644
--- a/packer.go
+++ b/main.go
@@ -2,17 +2,20 @@
 package main
 
 import (
-	"bytes"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
-	"github.com/mitchellh/packer/packer/plugin"
-	"github.com/mitchellh/panicwrap"
 	"io"
 	"io/ioutil"
 	"log"
 	"os"
 	"path/filepath"
 	"runtime"
+	"sync"
+
+	"github.com/mitchellh/cli"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/packer/plugin"
+	"github.com/mitchellh/panicwrap"
+	"github.com/mitchellh/prefixedio"
 )
 
 func main() {
@@ -24,63 +27,82 @@ func main() {
 
 // realMain is executed from main and returns the exit status to exit with.
 func realMain() int {
-	// If there is no explicit number of Go threads to use, then set it
-	if os.Getenv("GOMAXPROCS") == "" {
-		runtime.GOMAXPROCS(runtime.NumCPU())
+	var wrapConfig panicwrap.WrapConfig
+
+	if !panicwrap.Wrapped(&wrapConfig) {
+		// Determine where logs should go in general (requested by the user)
+		logWriter, err := logOutput()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Couldn't setup log output: %s", err)
+			return 1
+		}
+		if logWriter == nil {
+			logWriter = ioutil.Discard
+		}
+
+		// We always send logs to a temporary file that we use in case
+		// there is a panic. Otherwise, we delete it.
+		logTempFile, err := ioutil.TempFile("", "packer-log")
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Couldn't setup logging tempfile: %s", err)
+			return 1
+		}
+		defer os.Remove(logTempFile.Name())
+		defer logTempFile.Close()
+
+		// Tell the logger to log to this file
+		os.Setenv(EnvLog, "")
+		os.Setenv(EnvLogFile, "")
+
+		// Setup the prefixed readers that send data properly to
+		// stdout/stderr.
+		doneCh := make(chan struct{})
+		outR, outW := io.Pipe()
+		go copyOutput(outR, doneCh)
+
+		// Create the configuration for panicwrap and wrap our executable
+		wrapConfig.Handler = panicHandler(logTempFile)
+		wrapConfig.Writer = io.MultiWriter(logTempFile, logWriter)
+		wrapConfig.Stdout = outW
+		exitStatus, err := panicwrap.Wrap(&wrapConfig)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "Couldn't start Packer: %s", err)
+			return 1
+		}
+
+		// If >= 0, we're the parent, so just exit
+		if exitStatus >= 0 {
+			// Close the stdout writer so that our copy process can finish
+			outW.Close()
+
+			// Wait for the output copying to finish
+			<-doneCh
+
+			return exitStatus
+		}
+
+		// We're the child, so just close the tempfile we made in order to
+		// save file handles since the tempfile is only used by the parent.
+		logTempFile.Close()
 	}
 
-	// Determine where logs should go in general (requested by the user)
-	logWriter, err := logOutput()
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Couldn't setup log output: %s", err)
-		return 1
-	}
-
-	// We also always send logs to a temporary file that we use in case
-	// there is a panic. Otherwise, we delete it.
-	logTempFile, err := ioutil.TempFile("", "packer-log")
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Couldn't setup logging tempfile: %s", err)
-		return 1
-	}
-	defer os.Remove(logTempFile.Name())
-	defer logTempFile.Close()
-
-	// Reset the log variables to minimize work in the subprocess
-	os.Setenv("PACKER_LOG", "")
-	os.Setenv("PACKER_LOG_FILE", "")
-
-	// Create the configuration for panicwrap and wrap our executable
-	wrapConfig := &panicwrap.WrapConfig{
-		Handler: panicHandler(logTempFile),
-		Writer:  io.MultiWriter(logTempFile, logWriter),
-	}
-
-	exitStatus, err := panicwrap.Wrap(wrapConfig)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Couldn't start Packer: %s", err)
-		return 1
-	}
-
-	if exitStatus >= 0 {
-		return exitStatus
-	}
-
-	// We're the child, so just close the tempfile we made in order to
-	// save file handles since the tempfile is only used by the parent.
-	logTempFile.Close()
-
+	// Call the real main
 	return wrappedMain()
 }
 
 // wrappedMain is called only when we're wrapped by panicwrap and
 // returns the exit status to exit with.
 func wrappedMain() int {
+	// If there is no explicit number of Go threads to use, then set it
+	if os.Getenv("GOMAXPROCS") == "" {
+		runtime.GOMAXPROCS(runtime.NumCPU())
+	}
+
 	log.SetOutput(os.Stderr)
 
 	log.Printf(
-		"Packer Version: %s %s %s",
-		packer.Version, packer.VersionPrerelease, packer.GitCommit)
+		"[INFO] Packer version: %s %s %s",
+		Version, VersionPrerelease, GitCommit)
 	log.Printf("Packer Target OS/Arch: %s %s", runtime.GOOS, runtime.GOARCH)
 	log.Printf("Built with Go Version: %s", runtime.Version())
 
@@ -92,9 +114,11 @@ func wrappedMain() int {
 		fmt.Fprintf(os.Stderr, "Error loading configuration: \n\n%s\n", err)
 		return 1
 	}
-
 	log.Printf("Packer config: %+v", config)
 
+	// Fire off the checkpoint.
+	go runCheckpoint(config)
+
 	cacheDir := os.Getenv("PACKER_CACHE_DIR")
 	if cacheDir == "" {
 		cacheDir = "packer_cache"
@@ -116,16 +140,14 @@ func wrappedMain() int {
 	defer plugin.CleanupClients()
 
 	// Create the environment configuration
-	envConfig := packer.DefaultEnvironmentConfig()
-	envConfig.Cache = cache
-	envConfig.Commands = config.CommandNames()
-	envConfig.Components.Builder = config.LoadBuilder
-	envConfig.Components.Command = config.LoadCommand
-	envConfig.Components.Hook = config.LoadHook
-	envConfig.Components.PostProcessor = config.LoadPostProcessor
-	envConfig.Components.Provisioner = config.LoadProvisioner
+	EnvConfig = *packer.DefaultEnvironmentConfig()
+	EnvConfig.Cache = cache
+	EnvConfig.Components.Builder = config.LoadBuilder
+	EnvConfig.Components.Hook = config.LoadHook
+	EnvConfig.Components.PostProcessor = config.LoadPostProcessor
+	EnvConfig.Components.Provisioner = config.LoadProvisioner
 	if machineReadable {
-		envConfig.Ui = &packer.MachineReadableUi{
+		EnvConfig.Ui = &packer.MachineReadableUi{
 			Writer: os.Stdout,
 		}
 
@@ -137,17 +159,18 @@ func wrappedMain() int {
 		}
 	}
 
-	env, err := packer.NewEnvironment(envConfig)
-	if err != nil {
-		fmt.Fprintf(os.Stderr, "Packer initialization error: \n\n%s\n", err)
-		return 1
+	//setupSignalHandlers(env)
+
+	cli := &cli.CLI{
+		Args:       args,
+		Commands:   Commands,
+		HelpFunc:   cli.BasicHelpFunc("packer"),
+		HelpWriter: os.Stdout,
 	}
 
-	setupSignalHandlers(env)
-
-	exitCode, err := env.Cli(args)
+	exitCode, err := cli.Run()
 	if err != nil {
-		fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err.Error())
+		fmt.Fprintf(os.Stderr, "Error executing CLI: %s\n", err)
 		return 1
 	}
 
@@ -173,7 +196,9 @@ func extractMachineReadable(args []string) ([]string, bool) {
 
 func loadConfig() (*config, error) {
 	var config config
-	if err := decodeConfig(bytes.NewBufferString(defaultConfig), &config); err != nil {
+	config.PluginMinPort = 10000
+	config.PluginMaxPort = 25000
+	if err := config.Discover(); err != nil {
 		return nil, err
 	}
 
@@ -216,20 +241,44 @@ func loadConfig() (*config, error) {
 	return &config, nil
 }
 
-// logOutput determines where we should send logs (if anywhere).
-func logOutput() (logOutput io.Writer, err error) {
-	logOutput = ioutil.Discard
-	if os.Getenv("PACKER_LOG") != "" {
-		logOutput = os.Stderr
+// copyOutput uses output prefixes to determine whether data on stdout
+// should go to stdout or stderr. This is due to panicwrap using stderr
+// as the log and error channel.
+func copyOutput(r io.Reader, doneCh chan<- struct{}) {
+	defer close(doneCh)
 
-		if logPath := os.Getenv("PACKER_LOG_PATH"); logPath != "" {
-			var err error
-			logOutput, err = os.Create(logPath)
-			if err != nil {
-				return nil, err
-			}
-		}
+	pr, err := prefixedio.NewReader(r)
+	if err != nil {
+		panic(err)
 	}
 
-	return
+	stderrR, err := pr.Prefix(ErrorPrefix)
+	if err != nil {
+		panic(err)
+	}
+	stdoutR, err := pr.Prefix(OutputPrefix)
+	if err != nil {
+		panic(err)
+	}
+	defaultR, err := pr.Prefix("")
+	if err != nil {
+		panic(err)
+	}
+
+	var wg sync.WaitGroup
+	wg.Add(3)
+	go func() {
+		defer wg.Done()
+		io.Copy(os.Stderr, stderrR)
+	}()
+	go func() {
+		defer wg.Done()
+		io.Copy(os.Stdout, stdoutR)
+	}()
+	go func() {
+		defer wg.Done()
+		io.Copy(os.Stdout, defaultR)
+	}()
+
+	wg.Wait()
 }
diff --git a/packer_test.go b/main_test.go
similarity index 100%
rename from packer_test.go
rename to main_test.go
diff --git a/packer/artifact.go b/packer/artifact.go
index 486c322f6..8eaf3bcd5 100644
--- a/packer/artifact.go
+++ b/packer/artifact.go
@@ -25,6 +25,10 @@ type Artifact interface {
 	// This is used for UI output. It can be multiple lines.
 	String() string
 
+	// State allows the caller to ask for builder specific state information
+	// relating to the artifact instance.
+	State(name string) interface{}
+
 	// Destroy deletes the artifact. Packer calls this for various reasons,
 	// such as if a post-processor has processed this artifact and it is
 	// no longer needed.
diff --git a/packer/artifact_mock.go b/packer/artifact_mock.go
index a59af5331..18f4e562f 100644
--- a/packer/artifact_mock.go
+++ b/packer/artifact_mock.go
@@ -5,6 +5,7 @@ type MockArtifact struct {
 	BuilderIdValue string
 	FilesValue     []string
 	IdValue        string
+	StateValues    map[string]interface{}
 	DestroyCalled  bool
 }
 
@@ -37,6 +38,11 @@ func (*MockArtifact) String() string {
 	return "string"
 }
 
+func (a *MockArtifact) State(name string) interface{} {
+	value, _ := a.StateValues[name]
+	return value
+}
+
 func (a *MockArtifact) Destroy() error {
 	a.DestroyCalled = true
 	return nil
diff --git a/packer/artifact_test.go b/packer/artifact_test.go
index ab6f39fb4..4ddc5f0ac 100644
--- a/packer/artifact_test.go
+++ b/packer/artifact_test.go
@@ -2,6 +2,7 @@ package packer
 
 type TestArtifact struct {
 	id            string
+	state         map[string]interface{}
 	destroyCalled bool
 }
 
@@ -26,6 +27,11 @@ func (*TestArtifact) String() string {
 	return "string"
 }
 
+func (a *TestArtifact) State(name string) interface{} {
+	value, _ := a.state[name]
+	return value
+}
+
 func (a *TestArtifact) Destroy() error {
 	a.destroyCalled = true
 	return nil
diff --git a/packer/command.go b/packer/command.go
deleted file mode 100644
index d861347eb..000000000
--- a/packer/command.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package packer
-
-// A command is a runnable sub-command of the `packer` application.
-// When `packer` is called with the proper subcommand, this will be
-// called.
-//
-// The mapping of command names to command interfaces is in the
-// Environment struct.
-type Command interface {
-	// Help should return long-form help text that includes the command-line
-	// usage, a brief few sentences explaining the function of the command,
-	// and the complete list of flags the command accepts.
-	Help() string
-
-	// Run should run the actual command with the given environmet and
-	// command-line arguments. It should return the exit status when it is
-	// finished.
-	Run(env Environment, args []string) int
-
-	// Synopsis should return a one-line, short synopsis of the command.
-	// This should be less than 50 characters ideally.
-	Synopsis() string
-}
diff --git a/packer/command_test.go b/packer/command_test.go
deleted file mode 100644
index 06348fdac..000000000
--- a/packer/command_test.go
+++ /dev/null
@@ -1,22 +0,0 @@
-package packer
-
-type TestCommand struct {
-	runArgs   []string
-	runCalled bool
-	runEnv    Environment
-}
-
-func (tc *TestCommand) Help() string {
-	return "bar"
-}
-
-func (tc *TestCommand) Run(env Environment, args []string) int {
-	tc.runCalled = true
-	tc.runArgs = args
-	tc.runEnv = env
-	return 0
-}
-
-func (tc *TestCommand) Synopsis() string {
-	return "foo"
-}
diff --git a/packer/communicator.go b/packer/communicator.go
index 159e5e380..448e4aacf 100644
--- a/packer/communicator.go
+++ b/packer/communicator.go
@@ -3,6 +3,7 @@ package packer
 import (
 	"github.com/mitchellh/iochan"
 	"io"
+	"os"
 	"strings"
 	"sync"
 )
@@ -57,7 +58,7 @@ type Communicator interface {
 	// Upload uploads a file to the machine to the given path with the
 	// contents coming from the given reader. This method will block until
 	// it completes.
-	Upload(string, io.Reader) error
+	Upload(string, io.Reader, *os.FileInfo) error
 
 	// UploadDir uploads the contents of a directory recursively to
 	// the remote path. It also takes an optional slice of paths to
diff --git a/packer/communicator_mock.go b/packer/communicator_mock.go
index 30539f6f1..048fc3c3b 100644
--- a/packer/communicator_mock.go
+++ b/packer/communicator_mock.go
@@ -3,6 +3,7 @@ package packer
 import (
 	"bytes"
 	"io"
+	"os"
 	"sync"
 )
 
@@ -68,7 +69,7 @@ func (c *MockCommunicator) Start(rc *RemoteCmd) error {
 	return nil
 }
 
-func (c *MockCommunicator) Upload(path string, r io.Reader) error {
+func (c *MockCommunicator) Upload(path string, r io.Reader, fi *os.FileInfo) error {
 	c.UploadCalled = true
 	c.UploadPath = path
 
diff --git a/packer/config_template.go b/packer/config_template.go
index d76e3e672..47b096227 100644
--- a/packer/config_template.go
+++ b/packer/config_template.go
@@ -3,11 +3,13 @@ package packer
 import (
 	"bytes"
 	"fmt"
-	"github.com/mitchellh/packer/common/uuid"
 	"os"
 	"strconv"
+	"strings"
 	"text/template"
 	"time"
+
+	"github.com/mitchellh/packer/common/uuid"
 )
 
 // InitTime is the UTC time when this package was initialized. It is
@@ -43,6 +45,8 @@ func NewConfigTemplate() (*ConfigTemplate, error) {
 		"timestamp": templateTimestamp,
 		"user":      result.templateUser,
 		"uuid":      templateUuid,
+		"upper":     strings.ToUpper,
+		"lower":     strings.ToLower,
 	})
 
 	return result, nil
@@ -90,7 +94,7 @@ func (t *ConfigTemplate) nextTemplateName() string {
 func (t *ConfigTemplate) templateUser(n string) (string, error) {
 	result, ok := t.UserVars[n]
 	if !ok {
-		return "", fmt.Errorf("uknown user var: %s", n)
+		return "", fmt.Errorf("unknown user var: %s", n)
 	}
 
 	return result, nil
@@ -110,8 +114,16 @@ func templateEnv(n string) string {
 	return os.Getenv(n)
 }
 
-func templateISOTime() string {
-	return time.Now().UTC().Format(time.RFC3339)
+func templateISOTime(timeFormat ...string) (string, error) {
+	if len(timeFormat) == 0 {
+		return time.Now().UTC().Format(time.RFC3339), nil
+	}
+
+	if len(timeFormat) > 1 {
+		return "", fmt.Errorf("too many values, 1 needed: %v", timeFormat)
+	}
+
+	return time.Now().UTC().Format(timeFormat[0]), nil
 }
 
 func templatePwd() (string, error) {
diff --git a/packer/config_template_test.go b/packer/config_template_test.go
index 8604f2c43..cdc5fd461 100644
--- a/packer/config_template_test.go
+++ b/packer/config_template_test.go
@@ -1,6 +1,7 @@
 package packer
 
 import (
+	"fmt"
 	"math"
 	"os"
 	"strconv"
@@ -42,6 +43,33 @@ func TestConfigTemplateProcess_isotime(t *testing.T) {
 	}
 }
 
+// Note must format with the magic Date: Mon Jan 2 15:04:05 -0700 MST 2006
+func TestConfigTemplateProcess_isotime_withFormat(t *testing.T) {
+	tpl, err := NewConfigTemplate()
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Checking for a too-many arguments error
+	// Because of the variadic function, compile time checking won't work
+	_, err = tpl.Process(`{{isotime "20060102" "huh"}}`, nil)
+	if err == nil {
+		t.Fatalf("err: cannot have more than 1 input")
+	}
+
+	result, err := tpl.Process(`{{isotime "20060102"}}`, nil)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	ti := time.Now().UTC()
+	val := fmt.Sprintf("%04d%02d%02d", ti.Year(), ti.Month(), ti.Day())
+
+	if result != val {
+		t.Fatalf("val: %s (formated: %s)", val, result)
+	}
+}
+
 func TestConfigTemplateProcess_pwd(t *testing.T) {
 	tpl, err := NewConfigTemplate()
 	if err != nil {
@@ -130,6 +158,42 @@ func TestConfigTemplateProcess_uuid(t *testing.T) {
 	}
 }
 
+func TestConfigTemplateProcess_upper(t *testing.T) {
+	tpl, err := NewConfigTemplate()
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	tpl.UserVars["foo"] = "bar"
+
+	result, err := tpl.Process(`{{user "foo" | upper}}`, nil)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if result != "BAR" {
+		t.Fatalf("bad: %s", result)
+	}
+}
+
+func TestConfigTemplateProcess_lower(t *testing.T) {
+	tpl, err := NewConfigTemplate()
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	tpl.UserVars["foo"] = "BAR"
+
+	result, err := tpl.Process(`{{user "foo" | lower}}`, nil)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if result != "bar" {
+		t.Fatalf("bad: %s", result)
+	}
+}
+
 func TestConfigTemplateValidate(t *testing.T) {
 	tpl, err := NewConfigTemplate()
 	if err != nil {
diff --git a/packer/environment.go b/packer/environment.go
index 510b849c6..58585ffcf 100644
--- a/packer/environment.go
+++ b/packer/environment.go
@@ -4,19 +4,12 @@ package packer
 import (
 	"errors"
 	"fmt"
-	"log"
 	"os"
-	"sort"
-	"strings"
-	"sync"
 )
 
 // The function type used to lookup Builder implementations.
 type BuilderFunc func(name string) (Builder, error)
 
-// The function type used to lookup Command implementations.
-type CommandFunc func(name string) (Command, error)
-
 // The function type used to lookup Hook implementations.
 type HookFunc func(name string) (Hook, error)
 
@@ -31,7 +24,6 @@ type ProvisionerFunc func(name string) (Provisioner, error)
 // commands, etc.
 type ComponentFinder struct {
 	Builder       BuilderFunc
-	Command       CommandFunc
 	Hook          HookFunc
 	PostProcessor PostProcessorFunc
 	Provisioner   ProvisionerFunc
@@ -45,7 +37,6 @@ type ComponentFinder struct {
 type Environment interface {
 	Builder(string) (Builder, error)
 	Cache() Cache
-	Cli([]string) (int, error)
 	Hook(string) (Hook, error)
 	PostProcessor(string) (PostProcessor, error)
 	Provisioner(string) (Provisioner, error)
@@ -56,7 +47,6 @@ type Environment interface {
 // environment.
 type coreEnvironment struct {
 	cache      Cache
-	commands   []string
 	components ComponentFinder
 	ui         Ui
 }
@@ -64,22 +54,14 @@ type coreEnvironment struct {
 // This struct configures new environments.
 type EnvironmentConfig struct {
 	Cache      Cache
-	Commands   []string
 	Components ComponentFinder
 	Ui         Ui
 }
 
-type helpCommandEntry struct {
-	i        int
-	key      string
-	synopsis string
-}
-
 // DefaultEnvironmentConfig returns a default EnvironmentConfig that can
 // be used to create a new enviroment with NewEnvironment with sane defaults.
 func DefaultEnvironmentConfig() *EnvironmentConfig {
 	config := &EnvironmentConfig{}
-	config.Commands = make([]string, 0)
 	config.Ui = &BasicUi{
 		Reader:      os.Stdin,
 		Writer:      os.Stdout,
@@ -98,7 +80,6 @@ func NewEnvironment(config *EnvironmentConfig) (resultEnv Environment, err error
 
 	env := &coreEnvironment{}
 	env.cache = config.Cache
-	env.commands = config.Commands
 	env.components = config.Components
 	env.ui = config.Ui
 
@@ -109,10 +90,6 @@ func NewEnvironment(config *EnvironmentConfig) (resultEnv Environment, err error
 		env.components.Builder = func(string) (Builder, error) { return nil, nil }
 	}
 
-	if env.components.Command == nil {
-		env.components.Command = func(string) (Command, error) { return nil, nil }
-	}
-
 	if env.components.Hook == nil {
 		env.components.Hook = func(string) (Hook, error) { return nil, nil }
 	}
@@ -199,159 +176,6 @@ func (e *coreEnvironment) Provisioner(name string) (p Provisioner, err error) {
 	return
 }
 
-// Executes a command as if it was typed on the command-line interface.
-// The return value is the exit code of the command.
-func (e *coreEnvironment) Cli(args []string) (result int, err error) {
-	log.Printf("Environment.Cli: %#v\n", args)
-
-	// If we have no arguments, just short-circuit here and print the help
-	if len(args) == 0 {
-		e.printHelp()
-		return 1, nil
-	}
-
-	// This variable will track whether or not we're supposed to print
-	// the help or not.
-	isHelp := false
-	for _, arg := range args {
-		if arg == "-h" || arg == "--help" {
-			isHelp = true
-			break
-		}
-	}
-
-	// Trim up to the command name
-	for i, v := range args {
-		if len(v) > 0 && v[0] != '-' {
-			args = args[i:]
-			break
-		}
-	}
-
-	log.Printf("command + args: %#v", args)
-
-	version := args[0] == "version"
-	if !version {
-		for _, arg := range args {
-			if arg == "--version" || arg == "-v" {
-				version = true
-				break
-			}
-		}
-	}
-
-	var command Command
-	if version {
-		command = new(versionCommand)
-	}
-
-	if command == nil {
-		command, err = e.components.Command(args[0])
-		if err != nil {
-			return
-		}
-
-		// If we still don't have a command, show the help.
-		if command == nil {
-			e.ui.Error(fmt.Sprintf("Unknown command: %s\n", args[0]))
-			e.printHelp()
-			return 1, nil
-		}
-	}
-
-	// If we're supposed to print help, then print the help of the
-	// command rather than running it.
-	if isHelp {
-		e.ui.Say(command.Help())
-		return 0, nil
-	}
-
-	log.Printf("Executing command: %s\n", args[0])
-	return command.Run(e, args[1:]), nil
-}
-
-// Prints the CLI help to the UI.
-func (e *coreEnvironment) printHelp() {
-	// Created a sorted slice of the map keys and record the longest
-	// command name so we can better format the output later.
-	maxKeyLen := 0
-	for _, command := range e.commands {
-		if len(command) > maxKeyLen {
-			maxKeyLen = len(command)
-		}
-	}
-
-	// Sort the keys
-	sort.Strings(e.commands)
-
-	// Create the communication/sync mechanisms to get the synopsis' of
-	// the various commands. We do this in parallel since the overhead
-	// of the subprocess underneath is very expensive and this speeds things
-	// up an incredible amount.
-	var wg sync.WaitGroup
-	ch := make(chan *helpCommandEntry)
-
-	for i, key := range e.commands {
-		wg.Add(1)
-
-		// Get the synopsis in a goroutine since it may take awhile
-		// to subprocess out.
-		go func(i int, key string) {
-			defer wg.Done()
-			var synopsis string
-			command, err := e.components.Command(key)
-			if err != nil {
-				synopsis = fmt.Sprintf("Error loading command: %s", err.Error())
-			} else if command == nil {
-				return
-			} else {
-				synopsis = command.Synopsis()
-			}
-
-			// Pad the key with spaces so that they're all the same width
-			key = fmt.Sprintf("%s%s", key, strings.Repeat(" ", maxKeyLen-len(key)))
-
-			// Output the command and the synopsis
-			ch <- &helpCommandEntry{
-				i:        i,
-				key:      key,
-				synopsis: synopsis,
-			}
-		}(i, key)
-	}
-
-	e.ui.Say("usage: packer [--version] [--help] <command> [<args>]\n")
-	e.ui.Say("Available commands are:")
-
-	// Make a goroutine that just waits for all the synopsis gathering
-	// to complete, and then output it.
-	synopsisDone := make(chan struct{})
-	go func() {
-		defer close(synopsisDone)
-		entries := make([]string, len(e.commands))
-
-		for entry := range ch {
-			e.ui.Machine("command", entry.key, entry.synopsis)
-			message := fmt.Sprintf("    %s    %s", entry.key, entry.synopsis)
-			entries[entry.i] = message
-		}
-
-		for _, message := range entries {
-			if message != "" {
-				e.ui.Say(message)
-			}
-		}
-	}()
-
-	// Wait to complete getting the synopsis' then close the channel
-	wg.Wait()
-	close(ch)
-	<-synopsisDone
-
-	e.ui.Say("\nGlobally recognized options:")
-	e.ui.Say("    -machine-readable    Machine-readable output format.")
-}
-
 // Returns the UI for the environment. The UI is the interface that should
 // be used for all communication with the outside world.
 func (e *coreEnvironment) Ui() Ui {
diff --git a/packer/environment_test.go b/packer/environment_test.go
index c293c2a9a..80edab58e 100644
--- a/packer/environment_test.go
+++ b/packer/environment_test.go
@@ -6,8 +6,6 @@ import (
 	"io/ioutil"
 	"log"
 	"os"
-	"reflect"
-	"strings"
 	"testing"
 )
 
@@ -43,13 +41,6 @@ func testEnvironment() Environment {
 	return env
 }
 
-func TestEnvironment_DefaultConfig_Commands(t *testing.T) {
-	config := DefaultEnvironmentConfig()
-	if len(config.Commands) != 0 {
-		t.Fatalf("bad: %#v", config.Commands)
-	}
-}
-
 func TestEnvironment_DefaultConfig_Ui(t *testing.T) {
 	config := DefaultEnvironmentConfig()
 	if config.Ui == nil {
@@ -91,7 +82,6 @@ func TestEnvironment_NilComponents(t *testing.T) {
 	// anything but if there is a panic in the test then yeah, something
 	// went wrong.
 	env.Builder("foo")
-	env.Cli([]string{"foo"})
 	env.Hook("foo")
 	env.PostProcessor("foo")
 	env.Provisioner("foo")
@@ -154,117 +144,6 @@ func TestEnvironment_Cache(t *testing.T) {
 	}
 }
 
-func TestEnvironment_Cli_Error(t *testing.T) {
-	config := DefaultEnvironmentConfig()
-	config.Components.Command = func(n string) (Command, error) { return nil, errors.New("foo") }
-
-	env, _ := NewEnvironment(config)
-	_, err := env.Cli([]string{"foo"})
-	if err == nil {
-		t.Fatal("should have error")
-	}
-	if err.Error() != "foo" {
-		t.Fatalf("bad: %s", err)
-	}
-}
-
-func TestEnvironment_Cli_CallsRun(t *testing.T) {
-	command := &TestCommand{}
-	commands := make(map[string]Command)
-	commands["foo"] = command
-
-	config := &EnvironmentConfig{}
-	config.Commands = []string{"foo"}
-	config.Components.Command = func(n string) (Command, error) { return commands[n], nil }
-
-	env, _ := NewEnvironment(config)
-	exitCode, err := env.Cli([]string{"foo", "bar", "baz"})
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	if exitCode != 0 {
-		t.Fatalf("bad: %d", exitCode)
-	}
-	if !command.runCalled {
-		t.Fatal("command should be run")
-	}
-	if command.runEnv != env {
-		t.Fatalf("bad env: %#v", command.runEnv)
-	}
-	if !reflect.DeepEqual(command.runArgs, []string{"bar", "baz"}) {
-		t.Fatalf("bad: %#v", command.runArgs)
-	}
-}
-
-func TestEnvironment_DefaultCli_Empty(t *testing.T) {
-	defaultEnv := testEnvironment()
-
-	// Test with no args
-	exitCode, _ := defaultEnv.Cli([]string{})
-	if exitCode != 1 {
-		t.Fatalf("bad: %d", exitCode)
-	}
-
-	// Test with only blank args
-	exitCode, _ = defaultEnv.Cli([]string{""})
-	if exitCode != 1 {
-		t.Fatalf("bad: %d", exitCode)
-	}
-}
-
-func TestEnvironment_DefaultCli_Help(t *testing.T) {
-	defaultEnv := testEnvironment()
-
-	// A little lambda to help us test the output actually contains help
-	testOutput := func() {
-		buffer := defaultEnv.Ui().(*BasicUi).Writer.(*bytes.Buffer)
-		output := buffer.String()
-		buffer.Reset()
-		if !strings.Contains(output, "usage: packer") {
-			t.Fatalf("should contain help: %#v", output)
-		}
-	}
-
-	// Test "--help"
-	exitCode, _ := defaultEnv.Cli([]string{"--help"})
-	if exitCode != 1 {
-		t.Fatalf("bad: %d", exitCode)
-	}
-	testOutput()
-
-	// Test "-h"
-	exitCode, _ = defaultEnv.Cli([]string{"--help"})
-	if exitCode != 1 {
-		t.Fatalf("bad: %d", exitCode)
-	}
-	testOutput()
-}
-
-func TestEnvironment_DefaultCli_Version(t *testing.T) {
-	defaultEnv := testEnvironment()
-
-	versionCommands := []string{"version", "--version", "-v"}
-	for _, command := range versionCommands {
-		exitCode, _ := defaultEnv.Cli([]string{command})
-		if exitCode != 0 {
-			t.Fatalf("bad: %d", exitCode)
-		}
-
-		// Test the --version and -v can appear anywhere
-		exitCode, _ = defaultEnv.Cli([]string{"bad", command})
-
-		if command != "version" {
-			if exitCode != 0 {
-				t.Fatalf("bad: %d", exitCode)
-			}
-		} else {
-			if exitCode != 1 {
-				t.Fatalf("bad: %d", exitCode)
-			}
-		}
-	}
-}
-
 func TestEnvironment_Hook(t *testing.T) {
 	hook := &MockHook{}
 	hooks := make(map[string]Hook)
diff --git a/packer/plugin/client.go b/packer/plugin/client.go
index a06403f4f..36a5ce5a1 100644
--- a/packer/plugin/client.go
+++ b/packer/plugin/client.go
@@ -12,6 +12,7 @@ import (
 	"net"
 	"os"
 	"os/exec"
+	"path/filepath"
 	"strings"
 	"sync"
 	"time"
@@ -137,17 +138,6 @@ func (c *Client) Builder() (packer.Builder, error) {
 	return &cmdBuilder{client.Builder(), c}, nil
 }
 
-// Returns a command implementation that is communicating over this
-// client. If the client hasn't been started, this will start it.
-func (c *Client) Command() (packer.Command, error) {
-	client, err := c.packrpcClient()
-	if err != nil {
-		return nil, err
-	}
-
-	return &cmdCommand{client.Command(), c}, nil
-}
-
 // Returns a hook implementation that is communicating over this
 // client. If the client hasn't been started, this will start it.
 func (c *Client) Hook() (packer.Hook, error) {
@@ -355,7 +345,7 @@ func (c *Client) logStderr(r io.Reader) {
 			c.config.Stderr.Write([]byte(line))
 
 			line = strings.TrimRightFunc(line, unicode.IsSpace)
-			log.Printf("%s: %s", c.config.Cmd.Path, line)
+			log.Printf("%s: %s", filepath.Base(c.config.Cmd.Path), line)
 		}
 
 		if err == io.EOF {
diff --git a/packer/plugin/command.go b/packer/plugin/command.go
deleted file mode 100644
index c47f7b549..000000000
--- a/packer/plugin/command.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package plugin
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"log"
-)
-
-type cmdCommand struct {
-	command packer.Command
-	client  *Client
-}
-
-func (c *cmdCommand) Help() (result string) {
-	defer func() {
-		r := recover()
-		c.checkExit(r, func() { result = "" })
-	}()
-
-	result = c.command.Help()
-	return
-}
-
-func (c *cmdCommand) Run(e packer.Environment, args []string) (exitCode int) {
-	defer func() {
-		r := recover()
-		c.checkExit(r, func() { exitCode = 1 })
-	}()
-
-	exitCode = c.command.Run(e, args)
-	return
-}
-
-func (c *cmdCommand) Synopsis() (result string) {
-	defer func() {
-		r := recover()
-		c.checkExit(r, func() {
-			result = ""
-		})
-	}()
-
-	result = c.command.Synopsis()
-	return
-}
-
-func (c *cmdCommand) checkExit(p interface{}, cb func()) {
-	if c.client.Exited() {
-		cb()
-	} else if p != nil && !Killed {
-		log.Panic(p)
-	}
-}
diff --git a/packer/plugin/command_test.go b/packer/plugin/command_test.go
deleted file mode 100644
index 5c860c89c..000000000
--- a/packer/plugin/command_test.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package plugin
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"os/exec"
-	"testing"
-)
-
-type helperCommand byte
-
-func (helperCommand) Help() string {
-	return "2"
-}
-
-func (helperCommand) Run(packer.Environment, []string) int {
-	return 42
-}
-
-func (helperCommand) Synopsis() string {
-	return "1"
-}
-
-func TestCommand_NoExist(t *testing.T) {
-	c := NewClient(&ClientConfig{Cmd: exec.Command("i-should-not-exist")})
-	defer c.Kill()
-
-	_, err := c.Command()
-	if err == nil {
-		t.Fatal("should have error")
-	}
-}
-
-func TestCommand_Good(t *testing.T) {
-	c := NewClient(&ClientConfig{Cmd: helperProcess("command")})
-	defer c.Kill()
-
-	command, err := c.Command()
-	if err != nil {
-		t.Fatalf("should not have error: %s", err)
-	}
-
-	result := command.Synopsis()
-	if result != "1" {
-		t.Errorf("synopsis not correct: %s", result)
-	}
-
-	result = command.Help()
-	if result != "2" {
-		t.Errorf("help not correct: %s", result)
-	}
-}
diff --git a/packer/plugin/plugin_test.go b/packer/plugin/plugin_test.go
index d2cf2d201..23f994ea0 100644
--- a/packer/plugin/plugin_test.go
+++ b/packer/plugin/plugin_test.go
@@ -61,14 +61,6 @@ func TestHelperProcess(*testing.T) {
 		}
 		server.RegisterBuilder(new(packer.MockBuilder))
 		server.Serve()
-	case "command":
-		server, err := Server()
-		if err != nil {
-			log.Printf("[ERR] %s", err)
-			os.Exit(1)
-		}
-		server.RegisterCommand(new(helperCommand))
-		server.Serve()
 	case "hook":
 		server, err := Server()
 		if err != nil {
diff --git a/packer/plugin/server.go b/packer/plugin/server.go
index a36f8beda..23f39c028 100644
--- a/packer/plugin/server.go
+++ b/packer/plugin/server.go
@@ -10,7 +10,6 @@ package plugin
 import (
 	"errors"
 	"fmt"
-	"github.com/mitchellh/packer/packer"
 	packrpc "github.com/mitchellh/packer/packer/rpc"
 	"io/ioutil"
 	"log"
@@ -33,13 +32,11 @@ const MagicCookieValue = "d602bf8f470bc67ca7faa0386276bbdd4330efaf76d1a219cb4d69
 // The APIVersion is outputted along with the RPC address. The plugin
 // client validates this API version and will show an error if it doesn't
 // know how to speak it.
-const APIVersion = "3"
+const APIVersion = "4"
 
 // Server waits for a connection to this plugin and returns a Packer
 // RPC server that you can use to register components and serve them.
 func Server() (*packrpc.Server, error) {
-	log.Printf("Plugin build against Packer '%s'", packer.GitCommit)
-
 	if os.Getenv(MagicCookieKey) != MagicCookieValue {
 		return nil, errors.New(
 			"Please do not execute plugins directly. Packer will execute these for you.")
diff --git a/packer/rpc/artifact.go b/packer/rpc/artifact.go
index c6e0a208d..3532cfbad 100644
--- a/packer/rpc/artifact.go
+++ b/packer/rpc/artifact.go
@@ -38,6 +38,11 @@ func (a *artifact) String() (result string) {
 	return
 }
 
+func (a *artifact) State(name string) (result interface{}) {
+	a.client.Call(a.endpoint+".State", name, &result)
+	return
+}
+
 func (a *artifact) Destroy() error {
 	var result error
 	if err := a.client.Call(a.endpoint+".Destroy", new(interface{}), &result); err != nil {
@@ -67,6 +72,11 @@ func (s *ArtifactServer) String(args *interface{}, reply *string) error {
 	return nil
 }
 
+func (s *ArtifactServer) State(name string, reply *interface{}) error {
+	*reply = s.artifact.State(name)
+	return nil
+}
+
 func (s *ArtifactServer) Destroy(args *interface{}, reply *error) error {
 	err := s.artifact.Destroy()
 	if err != nil {
diff --git a/packer/rpc/build.go b/packer/rpc/build.go
index c2e6dceca..4d0b7edf4 100644
--- a/packer/rpc/build.go
+++ b/packer/rpc/build.go
@@ -9,14 +9,14 @@ import (
 // over an RPC connection.
 type build struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // BuildServer wraps a packer.Build implementation and makes it exportable
 // as part of a Golang RPC server.
 type BuildServer struct {
 	build packer.Build
-	mux   *MuxConn
+	mux   *muxBroker
 }
 
 type BuildPrepareResponse struct {
diff --git a/packer/rpc/builder.go b/packer/rpc/builder.go
index 5e3f429b5..0e2464bd7 100644
--- a/packer/rpc/builder.go
+++ b/packer/rpc/builder.go
@@ -10,14 +10,14 @@ import (
 // over an RPC connection.
 type builder struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // BuilderServer wraps a packer.Builder implementation and makes it exportable
 // as part of a Golang RPC server.
 type BuilderServer struct {
 	builder packer.Builder
-	mux     *MuxConn
+	mux     *muxBroker
 }
 
 type BuilderPrepareArgs struct {
diff --git a/packer/rpc/cache.go b/packer/rpc/cache.go
index 184286411..a4539ae66 100644
--- a/packer/rpc/cache.go
+++ b/packer/rpc/cache.go
@@ -2,6 +2,7 @@ package rpc
 
 import (
 	"github.com/mitchellh/packer/packer"
+	"log"
 	"net/rpc"
 )
 
@@ -24,7 +25,8 @@ type CacheRLockResponse struct {
 
 func (c *cache) Lock(key string) (result string) {
 	if err := c.client.Call("Cache.Lock", key, &result); err != nil {
-		panic(err)
+		log.Printf("[ERR] Cache.Lock error: %s", err)
+		return
 	}
 
 	return
@@ -33,7 +35,8 @@ func (c *cache) Lock(key string) (result string) {
 func (c *cache) RLock(key string) (string, bool) {
 	var result CacheRLockResponse
 	if err := c.client.Call("Cache.RLock", key, &result); err != nil {
-		panic(err)
+		log.Printf("[ERR] Cache.RLock error: %s", err)
+		return "", false
 	}
 
 	return result.Path, result.Exists
@@ -41,13 +44,15 @@ func (c *cache) RLock(key string) (string, bool) {
 
 func (c *cache) Unlock(key string) {
 	if err := c.client.Call("Cache.Unlock", key, new(interface{})); err != nil {
-		panic(err)
+		log.Printf("[ERR] Cache.Unlock error: %s", err)
+		return
 	}
 }
 
 func (c *cache) RUnlock(key string) {
 	if err := c.client.Call("Cache.RUnlock", key, new(interface{})); err != nil {
-		panic(err)
+		log.Printf("[ERR] Cache.RUnlock error: %s", err)
+		return
 	}
 }
 
diff --git a/packer/rpc/client.go b/packer/rpc/client.go
index 0cc8fc869..0e0140028 100644
--- a/packer/rpc/client.go
+++ b/packer/rpc/client.go
@@ -1,8 +1,8 @@
 package rpc
 
 import (
+	"github.com/hashicorp/go-msgpack/codec"
 	"github.com/mitchellh/packer/packer"
-	"github.com/ugorji/go/codec"
 	"io"
 	"log"
 	"net/rpc"
@@ -12,29 +12,39 @@ import (
 // Establishing a connection is up to the user, the Client can just
 // communicate over any ReadWriteCloser.
 type Client struct {
-	mux      *MuxConn
+	mux      *muxBroker
 	client   *rpc.Client
 	closeMux bool
 }
 
 func NewClient(rwc io.ReadWriteCloser) (*Client, error) {
-	result, err := newClientWithMux(NewMuxConn(rwc), 0)
+	mux, err := newMuxBrokerClient(rwc)
 	if err != nil {
 		return nil, err
 	}
+	go mux.Run()
+
+	result, err := newClientWithMux(mux, 0)
+	if err != nil {
+		mux.Close()
+		return nil, err
+	}
 
 	result.closeMux = true
 	return result, err
 }
 
-func newClientWithMux(mux *MuxConn, streamId uint32) (*Client, error) {
+func newClientWithMux(mux *muxBroker, streamId uint32) (*Client, error) {
 	clientConn, err := mux.Dial(streamId)
 	if err != nil {
 		return nil, err
 	}
 
-	var h codec.MsgpackHandle
-	clientCodec := codec.GoRpc.ClientCodec(clientConn, &h)
+	h := &codec.MsgpackHandle{
+		RawToString: true,
+		WriteExt:    true,
+	}
+	clientCodec := codec.GoRpc.ClientCodec(clientConn, h)
 
 	return &Client{
 		mux:      mux,
@@ -83,13 +93,6 @@ func (c *Client) Cache() packer.Cache {
 	}
 }
 
-func (c *Client) Command() packer.Command {
-	return &command{
-		client: c.client,
-		mux:    c.mux,
-	}
-}
-
 func (c *Client) Communicator() packer.Communicator {
 	return &communicator{
 		client: c.client,
diff --git a/packer/rpc/command.go b/packer/rpc/command.go
deleted file mode 100644
index 1484e5225..000000000
--- a/packer/rpc/command.go
+++ /dev/null
@@ -1,84 +0,0 @@
-package rpc
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"net/rpc"
-)
-
-// A Command is an implementation of the packer.Command interface where the
-// command is actually executed over an RPC connection.
-type command struct {
-	client *rpc.Client
-	mux    *MuxConn
-}
-
-// A CommandServer wraps a packer.Command and makes it exportable as part
-// of a Golang RPC server.
-type CommandServer struct {
-	command packer.Command
-	mux     *MuxConn
-}
-
-type CommandRunArgs struct {
-	Args     []string
-	StreamId uint32
-}
-
-type CommandSynopsisArgs byte
-
-func (c *command) Help() (result string) {
-	err := c.client.Call("Command.Help", new(interface{}), &result)
-	if err != nil {
-		panic(err)
-	}
-
-	return
-}
-
-func (c *command) Run(env packer.Environment, args []string) (result int) {
-	nextId := c.mux.NextId()
-	server := newServerWithMux(c.mux, nextId)
-	server.RegisterEnvironment(env)
-	go server.Serve()
-
-	rpcArgs := &CommandRunArgs{
-		Args:     args,
-		StreamId: nextId,
-	}
-	err := c.client.Call("Command.Run", rpcArgs, &result)
-	if err != nil {
-		panic(err)
-	}
-
-	return
-}
-
-func (c *command) Synopsis() (result string) {
-	err := c.client.Call("Command.Synopsis", CommandSynopsisArgs(0), &result)
-	if err != nil {
-		panic(err)
-	}
-
-	return
-}
-
-func (c *CommandServer) Help(args *interface{}, reply *string) error {
-	*reply = c.command.Help()
-	return nil
-}
-
-func (c *CommandServer) Run(args *CommandRunArgs, reply *int) error {
-	client, err := newClientWithMux(c.mux, args.StreamId)
-	if err != nil {
-		return NewBasicError(err)
-	}
-	defer client.Close()
-
-	*reply = c.command.Run(client.Environment(), args.Args)
-	return nil
-}
-
-func (c *CommandServer) Synopsis(args *CommandSynopsisArgs, reply *string) error {
-	*reply = c.command.Synopsis()
-	return nil
-}
diff --git a/packer/rpc/command_test.go b/packer/rpc/command_test.go
deleted file mode 100644
index 7ba433956..000000000
--- a/packer/rpc/command_test.go
+++ /dev/null
@@ -1,71 +0,0 @@
-package rpc
-
-import (
-	"github.com/mitchellh/packer/packer"
-	"reflect"
-	"testing"
-)
-
-type TestCommand struct {
-	runArgs   []string
-	runCalled bool
-	runEnv    packer.Environment
-}
-
-func (tc *TestCommand) Help() string {
-	return "bar"
-}
-
-func (tc *TestCommand) Run(env packer.Environment, args []string) int {
-	tc.runCalled = true
-	tc.runArgs = args
-	tc.runEnv = env
-	return 0
-}
-
-func (tc *TestCommand) Synopsis() string {
-	return "foo"
-}
-
-func TestRPCCommand(t *testing.T) {
-	// Create the command
-	command := new(TestCommand)
-
-	// Start the server
-	client, server := testClientServer(t)
-	defer client.Close()
-	defer server.Close()
-	server.RegisterCommand(command)
-	commClient := client.Command()
-
-	//Test Help
-	help := commClient.Help()
-	if help != "bar" {
-		t.Fatalf("bad: %s", help)
-	}
-
-	// Test run
-	runArgs := []string{"foo", "bar"}
-	testEnv := &testEnvironment{}
-	exitCode := commClient.Run(testEnv, runArgs)
-	if !reflect.DeepEqual(command.runArgs, runArgs) {
-		t.Fatalf("bad: %#v", command.runArgs)
-	}
-	if exitCode != 0 {
-		t.Fatalf("bad: %d", exitCode)
-	}
-
-	if command.runEnv == nil {
-		t.Fatal("runEnv should not be nil")
-	}
-
-	// Test Synopsis
-	synopsis := commClient.Synopsis()
-	if synopsis != "foo" {
-		t.Fatalf("bad: %#v", synopsis)
-	}
-}
-
-func TestCommand_Implements(t *testing.T) {
-	var _ packer.Command = new(command)
-}
diff --git a/packer/rpc/communicator.go b/packer/rpc/communicator.go
index 9ac539323..abf841af8 100644
--- a/packer/rpc/communicator.go
+++ b/packer/rpc/communicator.go
@@ -6,20 +6,21 @@ import (
 	"io"
 	"log"
 	"net/rpc"
+	"os"
 )
 
 // An implementation of packer.Communicator where the communicator is actually
 // executed over an RPC connection.
 type communicator struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // CommunicatorServer wraps a packer.Communicator implementation and makes
 // it exportable as part of a Golang RPC server.
 type CommunicatorServer struct {
 	c   packer.Communicator
-	mux *MuxConn
+	mux *muxBroker
 }
 
 type CommandFinished struct {
@@ -103,7 +104,7 @@ func (c *communicator) Start(cmd *packer.RemoteCmd) (err error) {
 	return
 }
 
-func (c *communicator) Upload(path string, r io.Reader) (err error) {
+func (c *communicator) Upload(path string, r io.Reader, fi *os.FileInfo) (err error) {
 	// Pipe the reader through to the connection
 	streamId := c.mux.NextId()
 	go serveSingleCopy("uploadData", c.mux, streamId, nil, r)
@@ -233,7 +234,7 @@ func (c *CommunicatorServer) Upload(args *CommunicatorUploadArgs, reply *interfa
 	}
 	defer readerC.Close()
 
-	err = c.c.Upload(args.Path, readerC)
+	err = c.c.Upload(args.Path, readerC, nil)
 	return
 }
 
@@ -252,7 +253,7 @@ func (c *CommunicatorServer) Download(args *CommunicatorDownloadArgs, reply *int
 	return
 }
 
-func serveSingleCopy(name string, mux *MuxConn, id uint32, dst io.Writer, src io.Reader) {
+func serveSingleCopy(name string, mux *muxBroker, id uint32, dst io.Writer, src io.Reader) {
 	conn, err := mux.Accept(id)
 	if err != nil {
 		log.Printf("[ERR] '%s' accept error: %s", name, err)
diff --git a/packer/rpc/communicator_test.go b/packer/rpc/communicator_test.go
index ca8239514..0e517aec9 100644
--- a/packer/rpc/communicator_test.go
+++ b/packer/rpc/communicator_test.go
@@ -82,7 +82,7 @@ func TestCommunicatorRPC(t *testing.T) {
 		defer uploadW.Close()
 		uploadW.Write([]byte("uploadfoo\n"))
 	}()
-	err = remote.Upload("foo", uploadR)
+	err = remote.Upload("foo", uploadR, nil)
 	if err != nil {
 		t.Fatalf("err: %s", err)
 	}
diff --git a/packer/rpc/environment.go b/packer/rpc/environment.go
index 644807bc4..4e2b73da8 100644
--- a/packer/rpc/environment.go
+++ b/packer/rpc/environment.go
@@ -10,18 +10,14 @@ import (
 // where the actual environment is executed over an RPC connection.
 type Environment struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // A EnvironmentServer wraps a packer.Environment and makes it exportable
 // as part of a Golang RPC server.
 type EnvironmentServer struct {
 	env packer.Environment
-	mux *MuxConn
-}
-
-type EnvironmentCliArgs struct {
-	Args []string
+	mux *muxBroker
 }
 
 func (e *Environment) Builder(name string) (b packer.Builder, err error) {
@@ -53,12 +49,6 @@ func (e *Environment) Cache() packer.Cache {
 	return client.Cache()
 }
 
-func (e *Environment) Cli(args []string) (result int, err error) {
-	rpcArgs := &EnvironmentCliArgs{args}
-	err = e.client.Call("Environment.Cli", rpcArgs, &result)
-	return
-}
-
 func (e *Environment) Hook(name string) (h packer.Hook, err error) {
 	var streamId uint32
 	err = e.client.Call("Environment.Hook", name, &streamId)
@@ -138,11 +128,6 @@ func (e *EnvironmentServer) Cache(args *interface{}, reply *uint32) error {
 	return nil
 }
 
-func (e *EnvironmentServer) Cli(args *EnvironmentCliArgs, reply *int) (err error) {
-	*reply, err = e.env.Cli(args.Args)
-	return
-}
-
 func (e *EnvironmentServer) Hook(name string, reply *uint32) error {
 	hook, err := e.env.Hook(name)
 	if err != nil {
diff --git a/packer/rpc/environment_test.go b/packer/rpc/environment_test.go
index bd0a6784a..a5085d0ef 100644
--- a/packer/rpc/environment_test.go
+++ b/packer/rpc/environment_test.go
@@ -2,7 +2,6 @@ package rpc
 
 import (
 	"github.com/mitchellh/packer/packer"
-	"reflect"
 	"testing"
 )
 
@@ -95,19 +94,6 @@ func TestEnvironmentRPC(t *testing.T) {
 		t.Fatal("should be called")
 	}
 
-	// Test Cli
-	cliArgs := []string{"foo", "bar"}
-	result, _ := eClient.Cli(cliArgs)
-	if !e.cliCalled {
-		t.Fatal("should be called")
-	}
-	if !reflect.DeepEqual(e.cliArgs, cliArgs) {
-		t.Fatalf("bad: %#v", e.cliArgs)
-	}
-	if result != 42 {
-		t.Fatalf("bad: %#v", result)
-	}
-
 	// Test Provisioner
 	_, _ = eClient.Provisioner("foo")
 	if !e.provCalled {
diff --git a/packer/rpc/hook.go b/packer/rpc/hook.go
index 6f149d41a..4aa7d75bc 100644
--- a/packer/rpc/hook.go
+++ b/packer/rpc/hook.go
@@ -10,14 +10,14 @@ import (
 // over an RPC connection.
 type hook struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // HookServer wraps a packer.Hook implementation and makes it exportable
 // as part of a Golang RPC server.
 type HookServer struct {
 	hook packer.Hook
-	mux  *MuxConn
+	mux  *muxBroker
 }
 
 type HookRunArgs struct {
diff --git a/packer/rpc/mux_broker.go b/packer/rpc/mux_broker.go
new file mode 100644
index 000000000..7af76f640
--- /dev/null
+++ b/packer/rpc/mux_broker.go
@@ -0,0 +1,191 @@
+package rpc
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+	"net"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/hashicorp/yamux"
+)
+
+// muxBroker is responsible for brokering multiplexed connections by unique ID.
+//
+// This allows a plugin to request a channel with a specific ID to connect to
+// or accept a connection from, and the broker handles the details of
+// holding these channels open while they're being negotiated.
+type muxBroker struct {
+	nextId  uint32
+	session *yamux.Session
+	streams map[uint32]*muxBrokerPending
+
+	sync.Mutex
+}
+
+type muxBrokerPending struct {
+	ch     chan net.Conn
+	doneCh chan struct{}
+}
+
+func newMuxBroker(s *yamux.Session) *muxBroker {
+	return &muxBroker{
+		session: s,
+		streams: make(map[uint32]*muxBrokerPending),
+	}
+}
+
+func newMuxBrokerClient(rwc io.ReadWriteCloser) (*muxBroker, error) {
+	s, err := yamux.Client(rwc, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return newMuxBroker(s), nil
+}
+
+func newMuxBrokerServer(rwc io.ReadWriteCloser) (*muxBroker, error) {
+	s, err := yamux.Server(rwc, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	return newMuxBroker(s), nil
+}
+
+// Accept accepts a connection by ID.
+//
+// This should not be called multiple times with the same ID at one time.
+func (m *muxBroker) Accept(id uint32) (net.Conn, error) {
+	var c net.Conn
+	p := m.getStream(id)
+	select {
+	case c = <-p.ch:
+		close(p.doneCh)
+	case <-time.After(5 * time.Second):
+		m.Lock()
+		defer m.Unlock()
+		delete(m.streams, id)
+
+		return nil, fmt.Errorf("timeout waiting for accept")
+	}
+
+	// Ack our connection
+	if err := binary.Write(c, binary.LittleEndian, id); err != nil {
+		c.Close()
+		return nil, err
+	}
+
+	return c, nil
+}
+
+// Close closes the connection and all sub-connections.
+func (m *muxBroker) Close() error {
+	return m.session.Close()
+}
+
+// Dial opens a connection by ID.
+func (m *muxBroker) Dial(id uint32) (net.Conn, error) {
+	// Open the stream
+	stream, err := m.session.OpenStream()
+	if err != nil {
+		return nil, err
+	}
+
+	// Write the stream ID onto the wire.
+	if err := binary.Write(stream, binary.LittleEndian, id); err != nil {
+		stream.Close()
+		return nil, err
+	}
+
+	// Read the ack that we connected. Then we're off!
+	var ack uint32
+	if err := binary.Read(stream, binary.LittleEndian, &ack); err != nil {
+		stream.Close()
+		return nil, err
+	}
+	if ack != id {
+		stream.Close()
+		return nil, fmt.Errorf("bad ack: %d (expected %d)", ack, id)
+	}
+
+	return stream, nil
+}
+
+// NextId returns a unique ID to use next.
+func (m *muxBroker) NextId() uint32 {
+	return atomic.AddUint32(&m.nextId, 1)
+}
+
+// Run starts the brokering and should be executed in a goroutine, since it
+// blocks forever, or until the session closes.
+func (m *muxBroker) Run() {
+	for {
+		stream, err := m.session.AcceptStream()
+		if err != nil {
+			// Once we receive an error, just exit
+			break
+		}
+
+		// Read the stream ID from the stream
+		var id uint32
+		if err := binary.Read(stream, binary.LittleEndian, &id); err != nil {
+			stream.Close()
+			continue
+		}
+
+		// Initialize the waiter
+		p := m.getStream(id)
+		select {
+		case p.ch <- stream:
+		default:
+		}
+
+		// Wait for a timeout
+		go m.timeoutWait(id, p)
+	}
+}
+
+func (m *muxBroker) getStream(id uint32) *muxBrokerPending {
+	m.Lock()
+	defer m.Unlock()
+
+	p, ok := m.streams[id]
+	if ok {
+		return p
+	}
+
+	m.streams[id] = &muxBrokerPending{
+		ch:     make(chan net.Conn, 1),
+		doneCh: make(chan struct{}),
+	}
+	return m.streams[id]
+}
+
+func (m *muxBroker) timeoutWait(id uint32, p *muxBrokerPending) {
+	// Wait for the stream to either be picked up and connected, or
+	// for a timeout.
+	timeout := false
+	select {
+	case <-p.doneCh:
+	case <-time.After(5 * time.Second):
+		timeout = true
+	}
+
+	m.Lock()
+	defer m.Unlock()
+
+	// Delete the stream so no one else can grab it
+	delete(m.streams, id)
+
+	// If we timed out, then check if we have a channel in the buffer,
+	// and if so, close it.
+	if timeout {
+		select {
+		case s := <-p.ch:
+			s.Close()
+		}
+	}
+}
diff --git a/packer/rpc/mux_broker_test.go b/packer/rpc/mux_broker_test.go
new file mode 100644
index 000000000..88739a0ff
--- /dev/null
+++ b/packer/rpc/mux_broker_test.go
@@ -0,0 +1,82 @@
+package rpc
+
+import (
+	"net"
+	"testing"
+
+	"github.com/hashicorp/yamux"
+)
+
+func TestMuxBroker(t *testing.T) {
+	c, s := testYamux(t)
+	defer c.Close()
+	defer s.Close()
+
+	bc := newMuxBroker(c)
+	bs := newMuxBroker(s)
+	go bc.Run()
+	go bs.Run()
+
+	go func() {
+		c, err := bc.Dial(5)
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		if _, err := c.Write([]byte{42}); err != nil {
+			t.Fatalf("err: %s", err)
+		}
+	}()
+
+	client, err := bs.Accept(5)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	var data [1]byte
+	if _, err := client.Read(data[:]); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if data[0] != 42 {
+		t.Fatalf("bad: %d", data[0])
+	}
+}
+
+func testYamux(t *testing.T) (client *yamux.Session, server *yamux.Session) {
+	l, err := net.Listen("tcp", "127.0.0.1:0")
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Server side
+	doneCh := make(chan struct{})
+	go func() {
+		defer close(doneCh)
+		conn, err := l.Accept()
+		l.Close()
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+
+		server, err = yamux.Server(conn, nil)
+		if err != nil {
+			t.Fatalf("err: %s", err)
+		}
+	}()
+
+	// Client side
+	conn, err := net.Dial("tcp", l.Addr().String())
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+	client, err = yamux.Client(conn, nil)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	// Wait for the server
+	<-doneCh
+
+	return
+}
diff --git a/packer/rpc/muxconn.go b/packer/rpc/muxconn.go
deleted file mode 100644
index bc9de8e72..000000000
--- a/packer/rpc/muxconn.go
+++ /dev/null
@@ -1,605 +0,0 @@
-package rpc
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-	"log"
-	"sync"
-	"time"
-)
-
-// MuxConn is able to multiplex multiple streams on top of any
-// io.ReadWriteCloser. These streams act like TCP connections (Dial, Accept,
-// Close, full duplex, etc.).
-//
-// The underlying io.ReadWriteCloser is expected to guarantee delivery
-// and ordering, such as TCP. Congestion control and such aren't implemented
-// by the streams, so that is also up to the underlying connection.
-//
-// MuxConn works using a fairly dumb multiplexing technique of simply
-// framing every piece of data sent into a prefix + data format. Streams
-// are established using a subset of the TCP protocol. Only a subset is
-// necessary since we assume ordering on the underlying RWC.
-type MuxConn struct {
-	curId         uint32
-	rwc           io.ReadWriteCloser
-	streamsAccept map[uint32]*Stream
-	streamsDial   map[uint32]*Stream
-	muAccept      sync.RWMutex
-	muDial        sync.RWMutex
-	wlock         sync.Mutex
-	doneCh        chan struct{}
-}
-
-type muxPacketFrom byte
-type muxPacketType byte
-
-const (
-	muxPacketFromAccept muxPacketFrom = iota
-	muxPacketFromDial
-)
-
-const (
-	muxPacketSyn muxPacketType = iota
-	muxPacketSynAck
-	muxPacketAck
-	muxPacketFin
-	muxPacketData
-)
-
-func (f muxPacketFrom) String() string {
-	switch f {
-	case muxPacketFromAccept:
-		return "accept"
-	case muxPacketFromDial:
-		return "dial"
-	default:
-		panic("unknown from type")
-	}
-}
-
-// Create a new MuxConn around any io.ReadWriteCloser.
-func NewMuxConn(rwc io.ReadWriteCloser) *MuxConn {
-	m := &MuxConn{
-		rwc:           rwc,
-		streamsAccept: make(map[uint32]*Stream),
-		streamsDial:   make(map[uint32]*Stream),
-		doneCh:        make(chan struct{}),
-	}
-
-	go m.cleaner()
-	go m.loop()
-
-	return m
-}
-
-// Close closes the underlying io.ReadWriteCloser. This will also close
-// all streams that are open.
-func (m *MuxConn) Close() error {
-	m.muAccept.Lock()
-	m.muDial.Lock()
-	defer m.muAccept.Unlock()
-	defer m.muDial.Unlock()
-
-	// Close all the streams
-	for _, w := range m.streamsAccept {
-		w.Close()
-	}
-	for _, w := range m.streamsDial {
-		w.Close()
-	}
-	m.streamsAccept = make(map[uint32]*Stream)
-	m.streamsDial = make(map[uint32]*Stream)
-
-	// Close the actual connection. This will also force the loop
-	// to end since it'll read EOF or closed connection.
-	return m.rwc.Close()
-}
-
-// Accept accepts a multiplexed connection with the given ID. This
-// will block until a request is made to connect.
-func (m *MuxConn) Accept(id uint32) (io.ReadWriteCloser, error) {
-	//log.Printf("[TRACE] %p: Accept on stream ID: %d", m, id)
-
-	// Get the stream. It is okay if it is already in the list of streams
-	// because we may have prematurely received a syn for it.
-	m.muAccept.Lock()
-	stream, ok := m.streamsAccept[id]
-	if !ok {
-		stream = newStream(muxPacketFromAccept, id, m)
-		m.streamsAccept[id] = stream
-	}
-	m.muAccept.Unlock()
-
-	stream.mu.Lock()
-	defer stream.mu.Unlock()
-
-	// If the stream isn't closed, then it is already open somehow
-	if stream.state != streamStateSynRecv && stream.state != streamStateClosed {
-		panic(fmt.Sprintf(
-			"Stream %d already open in bad state: %d", id, stream.state))
-	}
-
-	if stream.state == streamStateClosed {
-		// Go into the listening state and wait for a syn
-		stream.setState(streamStateListen)
-		if err := stream.waitState(streamStateSynRecv); err != nil {
-			return nil, err
-		}
-	}
-
-	if stream.state == streamStateSynRecv {
-		// Send a syn-ack
-		if _, err := stream.write(muxPacketSynAck, nil); err != nil {
-			return nil, err
-		}
-	}
-
-	if err := stream.waitState(streamStateEstablished); err != nil {
-		return nil, err
-	}
-
-	return stream, nil
-}
-
-// Dial opens a connection to the remote end using the given stream ID.
-// An Accept on the remote end will only work with if the IDs match.
-func (m *MuxConn) Dial(id uint32) (io.ReadWriteCloser, error) {
-	//log.Printf("[TRACE] %p: Dial on stream ID: %d", m, id)
-
-	m.muDial.Lock()
-
-	// If we have any streams with this ID, then it is a failure. The
-	// reaper should clear out old streams once in awhile.
-	if stream, ok := m.streamsDial[id]; ok {
-		m.muDial.Unlock()
-		panic(fmt.Sprintf(
-			"Stream %d already open for dial. State: %d",
-			id, stream.state))
-	}
-
-	// Create the new stream and put it in our list. We can then
-	// unlock because dialing will no longer be allowed on that ID.
-	stream := newStream(muxPacketFromDial, id, m)
-	m.streamsDial[id] = stream
-
-	// Don't let anyone else mess with this stream
-	stream.mu.Lock()
-	defer stream.mu.Unlock()
-
-	m.muDial.Unlock()
-
-	// Open a connection
-	if _, err := stream.write(muxPacketSyn, nil); err != nil {
-		return nil, err
-	}
-
-	// It is safe to set the state after the write above because
-	// we hold the stream lock.
-	stream.setState(streamStateSynSent)
-
-	if err := stream.waitState(streamStateEstablished); err != nil {
-		return nil, err
-	}
-
-	stream.write(muxPacketAck, nil)
-	return stream, nil
-}
-
-// NextId returns the next available listen stream ID that isn't currently
-// taken.
-func (m *MuxConn) NextId() uint32 {
-	m.muAccept.Lock()
-	defer m.muAccept.Unlock()
-
-	for {
-		// We never use stream ID 0 because 0 is the zero value of a uint32
-		// and we want to reserve that for "not in use"
-		if m.curId == 0 {
-			m.curId = 1
-		}
-
-		result := m.curId
-		m.curId += 1
-		if _, ok := m.streamsAccept[result]; !ok {
-			return result
-		}
-	}
-}
-
-func (m *MuxConn) cleaner() {
-	checks := []struct {
-		Map  *map[uint32]*Stream
-		Lock *sync.RWMutex
-	}{
-		{&m.streamsAccept, &m.muAccept},
-		{&m.streamsDial, &m.muDial},
-	}
-
-	for {
-		done := false
-		select {
-		case <-time.After(500 * time.Millisecond):
-		case <-m.doneCh:
-			done = true
-		}
-
-		for _, check := range checks {
-			check.Lock.Lock()
-			for id, s := range *check.Map {
-				s.mu.Lock()
-
-				if done && s.state != streamStateClosed {
-					s.closeWriter()
-				}
-
-				if s.state == streamStateClosed {
-					// Only clean up the streams that have been closed
-					// for a certain amount of time.
-					since := time.Now().UTC().Sub(s.stateUpdated)
-					if since > 2*time.Second {
-						delete(*check.Map, id)
-					}
-				}
-
-				s.mu.Unlock()
-			}
-			check.Lock.Unlock()
-		}
-
-		if done {
-			return
-		}
-	}
-}
-
-func (m *MuxConn) loop() {
-	// Force close every stream that we know about when we exit so
-	// that they all read EOF and don't block forever.
-	defer func() {
-		log.Printf("[INFO] Mux connection loop exiting")
-		close(m.doneCh)
-	}()
-
-	var from muxPacketFrom
-	var id uint32
-	var packetType muxPacketType
-	var length int32
-	for {
-		if err := binary.Read(m.rwc, binary.BigEndian, &from); err != nil {
-			log.Printf("[ERR] Error reading stream direction: %s", err)
-			return
-		}
-		if err := binary.Read(m.rwc, binary.BigEndian, &id); err != nil {
-			log.Printf("[ERR] Error reading stream ID: %s", err)
-			return
-		}
-		if err := binary.Read(m.rwc, binary.BigEndian, &packetType); err != nil {
-			log.Printf("[ERR] Error reading packet type: %s", err)
-			return
-		}
-		if err := binary.Read(m.rwc, binary.BigEndian, &length); err != nil {
-			log.Printf("[ERR] Error reading length: %s", err)
-			return
-		}
-
-		// TODO(mitchellh): probably would be better to re-use a buffer...
-		data := make([]byte, length)
-		n := 0
-		for n < int(length) {
-			if n2, err := m.rwc.Read(data[n:]); err != nil {
-				log.Printf("[ERR] Error reading data: %s", err)
-				return
-			} else {
-				n += n2
-			}
-		}
-
-		// Get the proper stream. Note that the map we look into is
-		// opposite the "from" because if the dial side is talking to
-		// us, we need to look into the accept map, and so on.
-		//
-		// Note: we also switch the "from" value so that logging
-		// below is correct.
-		var stream *Stream
-		switch from {
-		case muxPacketFromDial:
-			m.muAccept.Lock()
-			stream = m.streamsAccept[id]
-			m.muAccept.Unlock()
-
-			from = muxPacketFromAccept
-		case muxPacketFromAccept:
-			m.muDial.Lock()
-			stream = m.streamsDial[id]
-			m.muDial.Unlock()
-
-			from = muxPacketFromDial
-		default:
-			panic(fmt.Sprintf("Unknown stream direction: %d", from))
-		}
-
-		if stream == nil && packetType != muxPacketSyn {
-			log.Printf(
-				"[WARN] %p: Non-existent stream %d (%s) received packer %d",
-				m, id, from, packetType)
-			continue
-		}
-
-		//log.Printf("[TRACE] %p: Stream %d (%s) received packet %d", m, id, from, packetType)
-		switch packetType {
-		case muxPacketSyn:
-			// If the stream is nil, this is the only case where we'll
-			// automatically create the stream struct.
-			if stream == nil {
-				var ok bool
-
-				m.muAccept.Lock()
-				stream, ok = m.streamsAccept[id]
-				if !ok {
-					stream = newStream(muxPacketFromAccept, id, m)
-					m.streamsAccept[id] = stream
-				}
-				m.muAccept.Unlock()
-			}
-
-			stream.mu.Lock()
-			switch stream.state {
-			case streamStateClosed:
-				fallthrough
-			case streamStateListen:
-				stream.setState(streamStateSynRecv)
-			default:
-				log.Printf("[ERR] Syn received for stream in state: %d", stream.state)
-			}
-			stream.mu.Unlock()
-		case muxPacketAck:
-			stream.mu.Lock()
-			switch stream.state {
-			case streamStateSynRecv:
-				stream.setState(streamStateEstablished)
-			case streamStateFinWait1:
-				stream.setState(streamStateFinWait2)
-			case streamStateLastAck:
-				stream.closeWriter()
-				fallthrough
-			case streamStateClosing:
-				stream.setState(streamStateClosed)
-			default:
-				log.Printf("[ERR] Ack received for stream in state: %d", stream.state)
-			}
-			stream.mu.Unlock()
-		case muxPacketSynAck:
-			stream.mu.Lock()
-			switch stream.state {
-			case streamStateSynSent:
-				stream.setState(streamStateEstablished)
-			default:
-				log.Printf("[ERR] SynAck received for stream in state: %d", stream.state)
-			}
-			stream.mu.Unlock()
-		case muxPacketFin:
-			stream.mu.Lock()
-			switch stream.state {
-			case streamStateEstablished:
-				stream.closeWriter()
-				stream.setState(streamStateCloseWait)
-				stream.write(muxPacketAck, nil)
-			case streamStateFinWait2:
-				stream.closeWriter()
-				stream.setState(streamStateClosed)
-				stream.write(muxPacketAck, nil)
-			case streamStateFinWait1:
-				stream.closeWriter()
-				stream.setState(streamStateClosing)
-				stream.write(muxPacketAck, nil)
-			default:
-				log.Printf("[ERR] Fin received for stream %d in state: %d", id, stream.state)
-			}
-			stream.mu.Unlock()
-
-		case muxPacketData:
-			stream.mu.Lock()
-			switch stream.state {
-			case streamStateFinWait1:
-				fallthrough
-			case streamStateFinWait2:
-				fallthrough
-			case streamStateEstablished:
-				if len(data) > 0 && stream.writeCh != nil {
-					//log.Printf("[TRACE] %p: Stream %d (%s) WRITE-START", m, id, from)
-					stream.writeCh <- data
-					//log.Printf("[TRACE] %p: Stream %d (%s) WRITE-END", m, id, from)
-				}
-			default:
-				log.Printf("[ERR] Data received for stream in state: %d", stream.state)
-			}
-			stream.mu.Unlock()
-		}
-	}
-}
-
-func (m *MuxConn) write(from muxPacketFrom, id uint32, dataType muxPacketType, p []byte) (int, error) {
-	m.wlock.Lock()
-	defer m.wlock.Unlock()
-
-	if err := binary.Write(m.rwc, binary.BigEndian, from); err != nil {
-		return 0, err
-	}
-	if err := binary.Write(m.rwc, binary.BigEndian, id); err != nil {
-		return 0, err
-	}
-	if err := binary.Write(m.rwc, binary.BigEndian, byte(dataType)); err != nil {
-		return 0, err
-	}
-	if err := binary.Write(m.rwc, binary.BigEndian, int32(len(p))); err != nil {
-		return 0, err
-	}
-
-	// Write all the bytes. If we don't write all the bytes, report an error
-	var err error = nil
-	n := 0
-	for n < len(p) {
-		var n2 int
-		n2, err = m.rwc.Write(p[n:])
-		n += n2
-		if err != nil {
-			log.Printf("[ERR] %p: Stream %d (%s) write error: %s", m, id, from, err)
-			break
-		}
-	}
-
-	return n, err
-}
-
-// Stream is a single stream of data and implements io.ReadWriteCloser.
-// A Stream is full-duplex so you can write data as well as read data.
-type Stream struct {
-	from         muxPacketFrom
-	id           uint32
-	mux          *MuxConn
-	reader       io.Reader
-	state        streamState
-	stateChange  map[chan<- streamState]struct{}
-	stateUpdated time.Time
-	mu           sync.Mutex
-	writeCh      chan<- []byte
-}
-
-type streamState byte
-
-const (
-	streamStateClosed streamState = iota
-	streamStateListen
-	streamStateSynRecv
-	streamStateSynSent
-	streamStateEstablished
-	streamStateFinWait1
-	streamStateFinWait2
-	streamStateCloseWait
-	streamStateClosing
-	streamStateLastAck
-)
-
-func newStream(from muxPacketFrom, id uint32, m *MuxConn) *Stream {
-	// Create the stream object and channel where data will be sent to
-	dataR, dataW := io.Pipe()
-	writeCh := make(chan []byte, 4096)
-
-	// Set the data channel so we can write to it.
-	stream := &Stream{
-		from:        from,
-		id:          id,
-		mux:         m,
-		reader:      dataR,
-		writeCh:     writeCh,
-		stateChange: make(map[chan<- streamState]struct{}),
-	}
-	stream.setState(streamStateClosed)
-
-	// Start the goroutine that will read from the queue and write
-	// data out.
-	go func() {
-		defer dataW.Close()
-
-		drain := false
-		for {
-			data := <-writeCh
-			if data == nil {
-				// A nil is a tombstone letting us know we're done
-				// accepting data.
-				return
-			}
-
-			if drain {
-				// We're draining, meaning we're just waiting for the
-				// write channel to close.
-				continue
-			}
-
-			if _, err := dataW.Write(data); err != nil {
-				drain = true
-			}
-		}
-	}()
-
-	return stream
-}
-
-func (s *Stream) Close() error {
-	s.mu.Lock()
-	defer s.mu.Unlock()
-
-	if s.state != streamStateEstablished && s.state != streamStateCloseWait {
-		return fmt.Errorf("Stream in bad state: %d", s.state)
-	}
-
-	if s.state == streamStateEstablished {
-		s.setState(streamStateFinWait1)
-	} else {
-		s.setState(streamStateLastAck)
-	}
-
-	s.write(muxPacketFin, nil)
-	return nil
-}
-
-func (s *Stream) Read(p []byte) (int, error) {
-	return s.reader.Read(p)
-}
-
-func (s *Stream) Write(p []byte) (int, error) {
-	s.mu.Lock()
-	state := s.state
-	s.mu.Unlock()
-
-	if state != streamStateEstablished && state != streamStateCloseWait {
-		return 0, fmt.Errorf("Stream %d in bad state to send: %d", s.id, state)
-	}
-
-	return s.write(muxPacketData, p)
-}
-
-func (s *Stream) closeWriter() {
-	if s.writeCh != nil {
-		s.writeCh <- nil
-		s.writeCh = nil
-	}
-}
-
-func (s *Stream) setState(state streamState) {
-	//log.Printf("[TRACE] %p: Stream %d (%s) went to state %d", s.mux, s.id, s.from, state)
-	s.state = state
-	s.stateUpdated = time.Now().UTC()
-	for ch, _ := range s.stateChange {
-		select {
-		case ch <- state:
-		default:
-		}
-	}
-}
-
-func (s *Stream) waitState(target streamState) error {
-	// Register a state change listener to wait for changes
-	stateCh := make(chan streamState, 10)
-	s.stateChange[stateCh] = struct{}{}
-	s.mu.Unlock()
-
-	defer func() {
-		s.mu.Lock()
-		delete(s.stateChange, stateCh)
-	}()
-
-	//log.Printf("[TRACE] %p: Stream %d (%s) waiting for state: %d", s.mux, s.id, s.from, target)
-	state := <-stateCh
-	if state == target {
-		return nil
-	} else {
-		return fmt.Errorf("Stream %d went to bad state: %d", s.id, state)
-	}
-}
-
-func (s *Stream) write(dataType muxPacketType, p []byte) (int, error) {
-	return s.mux.write(s.from, s.id, dataType, p)
-}
diff --git a/packer/rpc/muxconn_test.go b/packer/rpc/muxconn_test.go
deleted file mode 100644
index 27a77fb46..000000000
--- a/packer/rpc/muxconn_test.go
+++ /dev/null
@@ -1,311 +0,0 @@
-package rpc
-
-import (
-	"io"
-	"net"
-	"sync"
-	"testing"
-)
-
-func readStream(t *testing.T, s io.Reader) string {
-	var data [1024]byte
-	n, err := s.Read(data[:])
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	return string(data[0:n])
-}
-
-func testMux(t *testing.T) (client *MuxConn, server *MuxConn) {
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	// Server side
-	doneCh := make(chan struct{})
-	go func() {
-		defer close(doneCh)
-		conn, err := l.Accept()
-		l.Close()
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		server = NewMuxConn(conn)
-	}()
-
-	// Client side
-	conn, err := net.Dial("tcp", l.Addr().String())
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	client = NewMuxConn(conn)
-
-	// Wait for the server
-	<-doneCh
-
-	return
-}
-
-func TestMuxConn(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-
-	// When the server is done
-	doneCh := make(chan struct{})
-
-	// The server side
-	go func() {
-		defer close(doneCh)
-
-		s0, err := server.Accept(0)
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		s1, err := server.Dial(1)
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		var wg sync.WaitGroup
-		wg.Add(2)
-
-		go func() {
-			defer wg.Done()
-			defer s1.Close()
-			data := readStream(t, s1)
-			if data != "another" {
-				t.Fatalf("bad: %#v", data)
-			}
-		}()
-
-		go func() {
-			defer wg.Done()
-			defer s0.Close()
-			data := readStream(t, s0)
-			if data != "hello" {
-				t.Fatalf("bad: %#v", data)
-			}
-		}()
-
-		wg.Wait()
-	}()
-
-	s0, err := client.Dial(0)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	s1, err := client.Accept(1)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if _, err := s0.Write([]byte("hello")); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-	if _, err := s1.Write([]byte("another")); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	s0.Close()
-	s1.Close()
-
-	// Wait for the server to be done
-	<-doneCh
-}
-
-func TestMuxConn_lotsOfData(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-
-	// When the server is done
-	doneCh := make(chan struct{})
-
-	// The server side
-	go func() {
-		defer close(doneCh)
-
-		s0, err := server.Accept(0)
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		var data [1024]byte
-		for {
-			n, err := s0.Read(data[:])
-			if err == io.EOF {
-				break
-			}
-
-			dataString := string(data[0:n])
-			if dataString != "hello" {
-				t.Fatalf("bad: %#v", dataString)
-			}
-		}
-
-		s0.Close()
-	}()
-
-	s0, err := client.Dial(0)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	for i := 0; i < 4096*4; i++ {
-		if _, err := s0.Write([]byte("hello")); err != nil {
-			t.Fatalf("err: %s", err)
-		}
-	}
-
-	if err := s0.Close(); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	// Wait for the server to be done
-	<-doneCh
-}
-
-// This tests that even when the client end is closed, data can be
-// read from the server.
-func TestMuxConn_clientCloseRead(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-
-	// This channel will be closed when we close
-	waitCh := make(chan struct{})
-
-	go func() {
-		conn, err := server.Accept(0)
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		<-waitCh
-
-		_, err = conn.Write([]byte("foo"))
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		conn.Close()
-	}()
-
-	s0, err := client.Dial(0)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if err := s0.Close(); err != nil {
-		t.Fatalf("bad: %s", err)
-	}
-
-	// Close this to continue on on the server-side
-	close(waitCh)
-
-	var data [1024]byte
-	n, err := s0.Read(data[:])
-	if string(data[:n]) != "foo" {
-		t.Fatalf("bad: %#v", string(data[:n]))
-	}
-}
-
-func TestMuxConn_socketClose(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-
-	go func() {
-		_, err := server.Accept(0)
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-
-		server.rwc.Close()
-	}()
-
-	s0, err := client.Dial(0)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	var data [1024]byte
-	_, err = s0.Read(data[:])
-	if err != io.EOF {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestMuxConn_clientClosesStreams(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-
-	go func() {
-		conn, err := server.Accept(0)
-		if err != nil {
-			t.Fatalf("err: %s", err)
-		}
-		conn.Close()
-	}()
-
-	s0, err := client.Dial(0)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	var data [1024]byte
-	_, err = s0.Read(data[:])
-	if err != io.EOF {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestMuxConn_serverClosesStreams(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-	go server.Accept(0)
-
-	s0, err := client.Dial(0)
-	if err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	if err := server.Close(); err != nil {
-		t.Fatalf("err: %s", err)
-	}
-
-	// This should block forever since we never write onto this stream.
-	var data [1024]byte
-	_, err = s0.Read(data[:])
-	if err != io.EOF {
-		t.Fatalf("err: %s", err)
-	}
-}
-
-func TestMuxConnNextId(t *testing.T) {
-	client, server := testMux(t)
-	defer client.Close()
-	defer server.Close()
-
-	a := client.NextId()
-	b := client.NextId()
-
-	if a != 1 || b != 2 {
-		t.Fatalf("IDs should increment")
-	}
-
-	a = server.NextId()
-	b = server.NextId()
-
-	if a != 1 || b != 2 {
-		t.Fatalf("IDs should increment: %d %d", a, b)
-	}
-}
diff --git a/packer/rpc/post_processor.go b/packer/rpc/post_processor.go
index 3a22c1a8a..b183780b9 100644
--- a/packer/rpc/post_processor.go
+++ b/packer/rpc/post_processor.go
@@ -9,14 +9,14 @@ import (
 // executed over an RPC connection.
 type postProcessor struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // PostProcessorServer wraps a packer.PostProcessor implementation and makes it
 // exportable as part of a Golang RPC server.
 type PostProcessorServer struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 	p      packer.PostProcessor
 }
 
diff --git a/packer/rpc/provisioner.go b/packer/rpc/provisioner.go
index 228203a2d..08d31700a 100644
--- a/packer/rpc/provisioner.go
+++ b/packer/rpc/provisioner.go
@@ -10,14 +10,14 @@ import (
 // executed over an RPC connection.
 type provisioner struct {
 	client *rpc.Client
-	mux    *MuxConn
+	mux    *muxBroker
 }
 
 // ProvisionerServer wraps a packer.Provisioner implementation and makes it
 // exportable as part of a Golang RPC server.
 type ProvisionerServer struct {
 	p   packer.Provisioner
-	mux *MuxConn
+	mux *muxBroker
 }
 
 type ProvisionerPrepareArgs struct {
@@ -26,7 +26,7 @@ type ProvisionerPrepareArgs struct {
 
 func (p *provisioner) Prepare(configs ...interface{}) (err error) {
 	args := &ProvisionerPrepareArgs{configs}
-	if cerr := p.client.Call("Provisioner.Prepare", args, &err); cerr != nil {
+	if cerr := p.client.Call("Provisioner.Prepare", args, new(interface{})); cerr != nil {
 		err = cerr
 	}
 
@@ -50,13 +50,8 @@ func (p *provisioner) Cancel() {
 	}
 }
 
-func (p *ProvisionerServer) Prepare(args *ProvisionerPrepareArgs, reply *error) error {
-	*reply = p.p.Prepare(args.Configs...)
-	if *reply != nil {
-		*reply = NewBasicError(*reply)
-	}
-
-	return nil
+func (p *ProvisionerServer) Prepare(args *ProvisionerPrepareArgs, reply *interface{}) error {
+	return p.p.Prepare(args.Configs...)
 }
 
 func (p *ProvisionerServer) Provision(streamId uint32, reply *interface{}) error {
diff --git a/packer/rpc/server.go b/packer/rpc/server.go
index df50f48ad..1f3e7eef2 100644
--- a/packer/rpc/server.go
+++ b/packer/rpc/server.go
@@ -2,8 +2,8 @@ package rpc
 
 import (
 	"fmt"
+	"github.com/hashicorp/go-msgpack/codec"
 	"github.com/mitchellh/packer/packer"
-	"github.com/ugorji/go/codec"
 	"io"
 	"log"
 	"net/rpc"
@@ -29,7 +29,7 @@ const (
 // Server represents an RPC server for Packer. This must be paired on
 // the other side with a Client.
 type Server struct {
-	mux      *MuxConn
+	mux      *muxBroker
 	streamId uint32
 	server   *rpc.Server
 	closeMux bool
@@ -37,12 +37,14 @@ type Server struct {
 
 // NewServer returns a new Packer RPC server.
 func NewServer(conn io.ReadWriteCloser) *Server {
-	result := newServerWithMux(NewMuxConn(conn), 0)
+	mux, _ := newMuxBrokerServer(conn)
+	result := newServerWithMux(mux, 0)
 	result.closeMux = true
+	go mux.Run()
 	return result
 }
 
-func newServerWithMux(mux *MuxConn, streamId uint32) *Server {
+func newServerWithMux(mux *muxBroker, streamId uint32) *Server {
 	return &Server{
 		mux:      mux,
 		streamId: streamId,
@@ -86,13 +88,6 @@ func (s *Server) RegisterCache(c packer.Cache) {
 	})
 }
 
-func (s *Server) RegisterCommand(c packer.Command) {
-	s.server.RegisterName(DefaultCommandEndpoint, &CommandServer{
-		command: c,
-		mux:     s.mux,
-	})
-}
-
 func (s *Server) RegisterCommunicator(c packer.Communicator) {
 	s.server.RegisterName(DefaultCommunicatorEndpoint, &CommunicatorServer{
 		c:   c,
@@ -140,14 +135,17 @@ func (s *Server) Serve() {
 	// Accept a connection on stream ID 0, which is always used for
 	// normal client to server connections.
 	stream, err := s.mux.Accept(s.streamId)
-	defer stream.Close()
 	if err != nil {
 		log.Printf("[ERR] Error retrieving stream for serving: %s", err)
 		return
 	}
+	defer stream.Close()
 
-	var h codec.MsgpackHandle
-	rpcCodec := codec.GoRpc.ServerCodec(stream, &h)
+	h := &codec.MsgpackHandle{
+		RawToString: true,
+		WriteExt:    true,
+	}
+	rpcCodec := codec.GoRpc.ServerCodec(stream, h)
 	s.server.ServeCodec(rpcCodec)
 }
 
diff --git a/packer/template.go b/packer/template.go
index a96b6758d..93f487d61 100644
--- a/packer/template.go
+++ b/packer/template.go
@@ -119,6 +119,8 @@ func ParseTemplate(data []byte, vars map[string]string) (t *Template, err error)
 	}
 
 	if rawTpl.MinimumPackerVersion != "" {
+		// TODO: NOPE! Replace this
+		Version := "1.0"
 		vCur, err := version.NewVersion(Version)
 		if err != nil {
 			panic(err)
@@ -131,8 +133,8 @@ func ParseTemplate(data []byte, vars map[string]string) (t *Template, err error)
 
 		if vCur.LessThan(vReq) {
 			return nil, fmt.Errorf(
-				"Template requires Packer version %s. " +
-				"Running version is %s.",
+				"Template requires Packer version %s. "+
+					"Running version is %s.",
 				vReq, vCur)
 		}
 	}
diff --git a/packer/ui.go b/packer/ui.go
index 4b082b38e..afd21a488 100644
--- a/packer/ui.go
+++ b/packer/ui.go
@@ -289,7 +289,7 @@ func (u *MachineReadableUi) Machine(category string, args ...string) {
 
 	_, err := fmt.Fprintf(u.Writer, "%d,%s,%s,%s\n", now.Unix(), target, category, argsString)
 	if err != nil {
-		if err == syscall.EPIPE {
+		if err == syscall.EPIPE || strings.Contains(err.Error(), "broken pipe") {
 			// Ignore epipe errors because that just means that the file
 			// is probably closed or going to /dev/null or something.
 		} else {
diff --git a/packer/version.go b/packer/version.go
deleted file mode 100644
index 07e36e01b..000000000
--- a/packer/version.go
+++ /dev/null
@@ -1,57 +0,0 @@
-package packer
-
-import (
-	"bytes"
-	"fmt"
-)
-
-// The git commit that is being compiled. This will be filled in by the
-// compiler for source builds.
-var GitCommit string
-
-// The version of packer.
-const Version = "0.6.0"
-
-// Any pre-release marker for the version. If this is "" (empty string),
-// then it means that it is a final release. Otherwise, this is the
-// pre-release marker.
-const VersionPrerelease = "dev"
-
-type versionCommand byte
-
-func (versionCommand) Help() string {
-	return `usage: packer version
-
-Outputs the version of Packer that is running. There are no additional
-command-line flags for this command.`
-}
-
-func (versionCommand) Run(env Environment, args []string) int {
-	env.Ui().Machine("version", Version)
-	env.Ui().Machine("version-prelease", VersionPrerelease)
-	env.Ui().Machine("version-commit", GitCommit)
-
-	env.Ui().Say(VersionString())
-	return 0
-}
-
-func (versionCommand) Synopsis() string {
-	return "print Packer version"
-}
-
-// VersionString returns the Packer version in human-readable
-// form complete with pre-release and git commit info if it is
-// available.
-func VersionString() string {
-	var versionString bytes.Buffer
-	fmt.Fprintf(&versionString, "Packer v%s", Version)
-	if VersionPrerelease != "" {
-		fmt.Fprintf(&versionString, ".%s", VersionPrerelease)
-
-		if GitCommit != "" {
-			fmt.Fprintf(&versionString, " (%s)", GitCommit)
-		}
-	}
-
-	return versionString.String()
-}
diff --git a/panic.go b/panic.go
index f02d47f2e..4f5d6a10b 100644
--- a/panic.go
+++ b/panic.go
@@ -2,10 +2,11 @@ package main
 
 import (
 	"fmt"
-	"github.com/mitchellh/panicwrap"
 	"io"
 	"os"
 	"strings"
+
+	"github.com/mitchellh/panicwrap"
 )
 
 // This is output if a panic happens.
diff --git a/plugin/command-fix/main.go b/plugin/builder-parallels-iso/main.go
similarity index 63%
rename from plugin/command-fix/main.go
rename to plugin/builder-parallels-iso/main.go
index 03677674d..9d0f85e43 100644
--- a/plugin/command-fix/main.go
+++ b/plugin/builder-parallels-iso/main.go
@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/mitchellh/packer/command/fix"
+	"github.com/mitchellh/packer/builder/parallels/iso"
 	"github.com/mitchellh/packer/packer/plugin"
 )
 
@@ -10,6 +10,6 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	server.RegisterCommand(new(fix.Command))
+	server.RegisterBuilder(new(iso.Builder))
 	server.Serve()
 }
diff --git a/plugin/command-build/main_test.go b/plugin/builder-parallels-iso/main_test.go
similarity index 100%
rename from plugin/command-build/main_test.go
rename to plugin/builder-parallels-iso/main_test.go
diff --git a/plugin/command-build/main.go b/plugin/builder-parallels-pvm/main.go
similarity index 63%
rename from plugin/command-build/main.go
rename to plugin/builder-parallels-pvm/main.go
index 1285e1e7a..36aafbd62 100644
--- a/plugin/command-build/main.go
+++ b/plugin/builder-parallels-pvm/main.go
@@ -1,7 +1,7 @@
 package main
 
 import (
-	"github.com/mitchellh/packer/command/build"
+	"github.com/mitchellh/packer/builder/parallels/pvm"
 	"github.com/mitchellh/packer/packer/plugin"
 )
 
@@ -10,6 +10,6 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	server.RegisterCommand(new(build.Command))
+	server.RegisterBuilder(new(pvm.Builder))
 	server.Serve()
 }
diff --git a/plugin/command-fix/main_test.go b/plugin/builder-parallels-pvm/main_test.go
similarity index 100%
rename from plugin/command-fix/main_test.go
rename to plugin/builder-parallels-pvm/main_test.go
diff --git a/plugin/command-inspect/main.go b/plugin/post-processor-compress/main.go
similarity index 59%
rename from plugin/command-inspect/main.go
rename to plugin/post-processor-compress/main.go
index 9aeedc34c..3acc85228 100644
--- a/plugin/command-inspect/main.go
+++ b/plugin/post-processor-compress/main.go
@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/mitchellh/packer/command/inspect"
 	"github.com/mitchellh/packer/packer/plugin"
+	"github.com/mitchellh/packer/post-processor/compress"
 )
 
 func main() {
@@ -10,6 +10,6 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	server.RegisterCommand(new(inspect.Command))
+	server.RegisterPostProcessor(new(compress.PostProcessor))
 	server.Serve()
 }
diff --git a/plugin/command-inspect/main_test.go b/plugin/post-processor-compress/main_test.go
similarity index 100%
rename from plugin/command-inspect/main_test.go
rename to plugin/post-processor-compress/main_test.go
diff --git a/plugin/post-processor-docker-save/main.go b/plugin/post-processor-docker-save/main.go
new file mode 100644
index 000000000..d5f5ec636
--- /dev/null
+++ b/plugin/post-processor-docker-save/main.go
@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/mitchellh/packer/packer/plugin"
+	"github.com/mitchellh/packer/post-processor/docker-save"
+)
+
+func main() {
+	server, err := plugin.Server()
+	if err != nil {
+		panic(err)
+	}
+	server.RegisterPostProcessor(new(dockersave.PostProcessor))
+	server.Serve()
+}
diff --git a/plugin/command-validate/main_test.go b/plugin/post-processor-docker-save/main_test.go
similarity index 100%
rename from plugin/command-validate/main_test.go
rename to plugin/post-processor-docker-save/main_test.go
diff --git a/plugin/command-validate/main.go b/plugin/post-processor-docker-tag/main.go
similarity index 58%
rename from plugin/command-validate/main.go
rename to plugin/post-processor-docker-tag/main.go
index 1105ed75e..e226ff697 100644
--- a/plugin/command-validate/main.go
+++ b/plugin/post-processor-docker-tag/main.go
@@ -1,8 +1,8 @@
 package main
 
 import (
-	"github.com/mitchellh/packer/command/validate"
 	"github.com/mitchellh/packer/packer/plugin"
+	"github.com/mitchellh/packer/post-processor/docker-tag"
 )
 
 func main() {
@@ -10,6 +10,6 @@ func main() {
 	if err != nil {
 		panic(err)
 	}
-	server.RegisterCommand(new(validate.Command))
+	server.RegisterPostProcessor(new(dockertag.PostProcessor))
 	server.Serve()
 }
diff --git a/plugin/post-processor-docker-tag/main_test.go b/plugin/post-processor-docker-tag/main_test.go
new file mode 100644
index 000000000..06ab7d0f9
--- /dev/null
+++ b/plugin/post-processor-docker-tag/main_test.go
@@ -0,0 +1 @@
+package main
diff --git a/plugin/post-processor-vagrant-cloud/main.go b/plugin/post-processor-vagrant-cloud/main.go
new file mode 100644
index 000000000..b5e3e7044
--- /dev/null
+++ b/plugin/post-processor-vagrant-cloud/main.go
@@ -0,0 +1,15 @@
+package main
+
+import (
+	"github.com/mitchellh/packer/packer/plugin"
+	"github.com/mitchellh/packer/post-processor/vagrant-cloud"
+)
+
+func main() {
+	server, err := plugin.Server()
+	if err != nil {
+		panic(err)
+	}
+	server.RegisterPostProcessor(new(vagrantcloud.PostProcessor))
+	server.Serve()
+}
diff --git a/plugin/post-processor-vagrant-cloud/main_test.go b/plugin/post-processor-vagrant-cloud/main_test.go
new file mode 100644
index 000000000..06ab7d0f9
--- /dev/null
+++ b/plugin/post-processor-vagrant-cloud/main_test.go
@@ -0,0 +1 @@
+package main
diff --git a/post-processor/compress/artifact.go b/post-processor/compress/artifact.go
new file mode 100644
index 000000000..34a7ce8d6
--- /dev/null
+++ b/post-processor/compress/artifact.go
@@ -0,0 +1,44 @@
+package compress
+
+import (
+	"fmt"
+	"os"
+)
+
+const BuilderId = "packer.post-processor.compress"
+
+type Artifact struct {
+	Path     string
+	Provider string
+}
+
+func NewArtifact(provider, path string) *Artifact {
+	return &Artifact{
+		Path:     path,
+		Provider: provider,
+	}
+}
+
+func (*Artifact) BuilderId() string {
+	return BuilderId
+}
+
+func (self *Artifact) Id() string {
+	return ""
+}
+
+func (self *Artifact) Files() []string {
+	return []string{self.Path}
+}
+
+func (self *Artifact) String() string {
+	return fmt.Sprintf("'%s' compressing: %s", self.Provider, self.Path)
+}
+
+func (*Artifact) State(name string) interface{} {
+	return nil
+}
+
+func (self *Artifact) Destroy() error {
+	return os.Remove(self.Path)
+}
diff --git a/post-processor/compress/artifact_test.go b/post-processor/compress/artifact_test.go
new file mode 100644
index 000000000..108ed84e7
--- /dev/null
+++ b/post-processor/compress/artifact_test.go
@@ -0,0 +1,14 @@
+package compress
+
+import (
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func TestArtifact_ImplementsArtifact(t *testing.T) {
+	var raw interface{}
+	raw = &Artifact{}
+	if _, ok := raw.(packer.Artifact); !ok {
+		t.Fatalf("Artifact should be a Artifact!")
+	}
+}
diff --git a/post-processor/compress/post-processor.go b/post-processor/compress/post-processor.go
new file mode 100644
index 000000000..003afd2a9
--- /dev/null
+++ b/post-processor/compress/post-processor.go
@@ -0,0 +1,119 @@
+package compress
+
+import (
+	"archive/tar"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"os"
+
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+)
+
+type Config struct {
+	common.PackerConfig `mapstructure:",squash"`
+
+	OutputPath string `mapstructure:"output"`
+
+	tpl *packer.ConfigTemplate
+}
+
+type PostProcessor struct {
+	config Config
+}
+
+func (self *PostProcessor) Configure(raws ...interface{}) error {
+	_, err := common.DecodeConfig(&self.config, raws...)
+	if err != nil {
+		return err
+	}
+
+	self.config.tpl, err = packer.NewConfigTemplate()
+	if err != nil {
+		return err
+	}
+	self.config.tpl.UserVars = self.config.PackerUserVars
+
+	templates := map[string]*string{
+		"output": &self.config.OutputPath,
+	}
+
+	errs := new(packer.MultiError)
+	for key, ptr := range templates {
+		if *ptr == "" {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("%s must be set", key))
+		}
+
+		*ptr, err = self.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", key, err))
+		}
+	}
+
+	if len(errs.Errors) > 0 {
+		return errs
+	}
+
+	return nil
+
+}
+
+func (self *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
+	ui.Say(fmt.Sprintf("Creating archive for '%s'", artifact.BuilderId()))
+
+	// Create the compressed archive file at the appropriate OutputPath.
+	fw, err := os.Create(self.config.OutputPath)
+	if err != nil {
+		return nil, false, fmt.Errorf(
+			"Failed creating file for compressed archive: %s", self.config.OutputPath)
+	}
+	defer fw.Close()
+
+	gw := gzip.NewWriter(fw)
+	defer gw.Close()
+
+	// Iterate through all of the artifact's files and put them into the
+	// compressed archive using the tar/gzip writers.
+	for _, path := range artifact.Files() {
+		fi, err := os.Stat(path)
+		if err != nil {
+			return nil, false, fmt.Errorf(
+				"Failed stating file: %s", path)
+		}
+
+		target, _ := os.Readlink(path)
+		header, err := tar.FileInfoHeader(fi, target)
+		if err != nil {
+			return nil, false, fmt.Errorf(
+				"Failed creating archive header: %s", path)
+		}
+
+		tw := tar.NewWriter(gw)
+		defer tw.Close()
+
+		// Write the header first to the archive. This takes partial data
+		// from the FileInfo that is grabbed by running the stat command.
+		if err := tw.WriteHeader(header); err != nil {
+			return nil, false, fmt.Errorf(
+				"Failed writing archive header: %s", path)
+		}
+
+		// Open the target file for archiving and compressing.
+		fr, err := os.Open(path)
+		if err != nil {
+			return nil, false, fmt.Errorf(
+				"Failed opening file '%s' to write compressed archive.", path)
+		}
+		defer fr.Close()
+
+		if _, err = io.Copy(tw, fr); err != nil {
+			return nil, false, fmt.Errorf(
+				"Failed copying file to archive: %s", path)
+		}
+	}
+
+	return NewArtifact(artifact.BuilderId(), self.config.OutputPath), false, nil
+}
diff --git a/post-processor/compress/post-processor_test.go b/post-processor/compress/post-processor_test.go
new file mode 100644
index 000000000..92cbfc4b3
--- /dev/null
+++ b/post-processor/compress/post-processor_test.go
@@ -0,0 +1,3 @@
+package compress
+
+import ()
diff --git a/post-processor/docker-push/post-processor.go b/post-processor/docker-push/post-processor.go
index 9007b303f..25b41afee 100644
--- a/post-processor/docker-push/post-processor.go
+++ b/post-processor/docker-push/post-processor.go
@@ -6,12 +6,19 @@ import (
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
 	"github.com/mitchellh/packer/post-processor/docker-import"
+	"github.com/mitchellh/packer/post-processor/docker-tag"
 	"strings"
 )
 
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
+	Login         bool
+	LoginEmail    string `mapstructure:"login_email"`
+	LoginUsername string `mapstructure:"login_username"`
+	LoginPassword string `mapstructure:"login_password"`
+	LoginServer   string `mapstructure:"login_server"`
+
 	tpl *packer.ConfigTemplate
 }
 
@@ -35,6 +42,24 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 
 	// Accumulate any errors
 	errs := new(packer.MultiError)
+
+	// Process templates
+	templates := map[string]*string{
+		"login_email":    &p.config.LoginEmail,
+		"login_username": &p.config.LoginUsername,
+		"login_password": &p.config.LoginPassword,
+		"login_server":   &p.config.LoginServer,
+	}
+
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = p.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
 	if len(errs.Errors) > 0 {
 		return errs
 	}
@@ -43,9 +68,10 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 }
 
 func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
-	if artifact.BuilderId() != dockerimport.BuilderId {
+	if artifact.BuilderId() != dockerimport.BuilderId &&
+		artifact.BuilderId() != dockertag.BuilderId {
 		err := fmt.Errorf(
-			"Unknown artifact type: %s\nCan only import from docker-import artifacts.",
+			"Unknown artifact type: %s\nCan only import from docker-import and docker-tag artifacts.",
 			artifact.BuilderId())
 		return nil, false, err
 	}
@@ -56,6 +82,26 @@ func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (pac
 		driver = &docker.DockerDriver{Tpl: p.config.tpl, Ui: ui}
 	}
 
+	if p.config.Login {
+		ui.Message("Logging in...")
+		err := driver.Login(
+			p.config.LoginServer,
+			p.config.LoginEmail,
+			p.config.LoginUsername,
+			p.config.LoginPassword)
+		if err != nil {
+			return nil, false, fmt.Errorf(
+				"Error logging in to Docker: %s", err)
+		}
+
+		defer func() {
+			ui.Message("Logging out...")
+			if err := driver.Logout(p.config.LoginServer); err != nil {
+				ui.Error(fmt.Sprintf("Error logging out: %s", err))
+			}
+		}()
+	}
+
 	// Get the name. We strip off any tags from the name because the
 	// push doesn't use those.
 	name := artifact.Id()
diff --git a/post-processor/docker-save/post-processor.go b/post-processor/docker-save/post-processor.go
new file mode 100644
index 000000000..6a2d86298
--- /dev/null
+++ b/post-processor/docker-save/post-processor.go
@@ -0,0 +1,104 @@
+package dockersave
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/builder/docker"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/post-processor/docker-import"
+	"os"
+)
+
+const BuilderId = "packer.post-processor.docker-save"
+
+type Config struct {
+	common.PackerConfig `mapstructure:",squash"`
+
+	Path string `mapstructure:"path"`
+
+	tpl *packer.ConfigTemplate
+}
+
+type PostProcessor struct {
+	Driver docker.Driver
+
+	config Config
+}
+
+func (p *PostProcessor) Configure(raws ...interface{}) error {
+	_, err := common.DecodeConfig(&p.config, raws...)
+	if err != nil {
+		return err
+	}
+
+	p.config.tpl, err = packer.NewConfigTemplate()
+	if err != nil {
+		return err
+	}
+	p.config.tpl.UserVars = p.config.PackerUserVars
+
+	// Accumulate any errors
+	errs := new(packer.MultiError)
+
+	templates := map[string]*string{
+		"path": &p.config.Path,
+	}
+
+	for key, ptr := range templates {
+		if *ptr == "" {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("%s must be set", key))
+		}
+
+		*ptr, err = p.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", key, err))
+		}
+	}
+
+	if len(errs.Errors) > 0 {
+		return errs
+	}
+
+	return nil
+
+}
+
+func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
+	if artifact.BuilderId() != dockerimport.BuilderId {
+		err := fmt.Errorf(
+			"Unknown artifact type: %s\nCan only save Docker builder artifacts.",
+			artifact.BuilderId())
+		return nil, false, err
+	}
+
+	path := p.config.Path
+
+	// Open the file that we're going to write to
+	f, err := os.Create(path)
+	if err != nil {
+		err := fmt.Errorf("Error creating output file: %s", err)
+		return nil, false, err
+	}
+
+	driver := p.Driver
+	if driver == nil {
+		// If no driver is set, then we use the real driver
+		driver = &docker.DockerDriver{Tpl: p.config.tpl, Ui: ui}
+	}
+
+	ui.Message("Saving image: " + artifact.Id())
+
+	if err := driver.SaveImage(artifact.Id(), f); err != nil {
+		f.Close()
+		os.Remove(f.Name())
+
+		return nil, false, err
+	}
+
+	f.Close()
+	ui.Message("Saved to: " + path)
+
+	return artifact, true, nil
+}
diff --git a/post-processor/docker-save/post-processor_test.go b/post-processor/docker-save/post-processor_test.go
new file mode 100644
index 000000000..2d29d58b9
--- /dev/null
+++ b/post-processor/docker-save/post-processor_test.go
@@ -0,0 +1,31 @@
+package dockersave
+
+import (
+	"bytes"
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{}
+}
+
+func testPP(t *testing.T) *PostProcessor {
+	var p PostProcessor
+	if err := p.Configure(testConfig()); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return &p
+}
+
+func testUi() *packer.BasicUi {
+	return &packer.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	}
+}
+
+func TestPostProcessor_ImplementsPostProcessor(t *testing.T) {
+	var _ packer.PostProcessor = new(PostProcessor)
+}
diff --git a/post-processor/docker-tag/post-processor.go b/post-processor/docker-tag/post-processor.go
new file mode 100644
index 000000000..d68b48e4c
--- /dev/null
+++ b/post-processor/docker-tag/post-processor.go
@@ -0,0 +1,103 @@
+package dockertag
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/builder/docker"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/post-processor/docker-import"
+)
+
+const BuilderId = "packer.post-processor.docker-tag"
+
+type Config struct {
+	common.PackerConfig `mapstructure:",squash"`
+
+	Repository string `mapstructure:"repository"`
+	Tag        string `mapstructure:"tag"`
+
+	tpl *packer.ConfigTemplate
+}
+
+type PostProcessor struct {
+	Driver docker.Driver
+
+	config Config
+}
+
+func (p *PostProcessor) Configure(raws ...interface{}) error {
+	_, err := common.DecodeConfig(&p.config, raws...)
+	if err != nil {
+		return err
+	}
+
+	p.config.tpl, err = packer.NewConfigTemplate()
+	if err != nil {
+		return err
+	}
+	p.config.tpl.UserVars = p.config.PackerUserVars
+
+	// Accumulate any errors
+	errs := new(packer.MultiError)
+
+	templates := map[string]*string{
+		"repository": &p.config.Repository,
+		"tag":        &p.config.Tag,
+	}
+
+	for key, ptr := range templates {
+		if *ptr == "" {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("%s must be set", key))
+		}
+
+		*ptr, err = p.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", key, err))
+		}
+	}
+
+	if len(errs.Errors) > 0 {
+		return errs
+	}
+
+	return nil
+
+}
+
+func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
+	if artifact.BuilderId() != dockerimport.BuilderId {
+		err := fmt.Errorf(
+			"Unknown artifact type: %s\nCan only tag from Docker builder artifacts.",
+			artifact.BuilderId())
+		return nil, false, err
+	}
+
+	driver := p.Driver
+	if driver == nil {
+		// If no driver is set, then we use the real driver
+		driver = &docker.DockerDriver{Tpl: p.config.tpl, Ui: ui}
+	}
+
+	importRepo := p.config.Repository
+	if p.config.Tag != "" {
+		importRepo += ":" + p.config.Tag
+	}
+
+	ui.Message("Tagging image: " + artifact.Id())
+	ui.Message("Repository: " + importRepo)
+	err := driver.TagImage(artifact.Id(), importRepo)
+	if err != nil {
+		return nil, false, err
+	}
+
+	// Build the artifact
+	artifact = &docker.ImportArtifact{
+		BuilderIdValue: BuilderId,
+		Driver:         driver,
+		IdValue:        importRepo,
+	}
+
+	return artifact, true, nil
+}
diff --git a/post-processor/docker-tag/post-processor_test.go b/post-processor/docker-tag/post-processor_test.go
new file mode 100644
index 000000000..925419a10
--- /dev/null
+++ b/post-processor/docker-tag/post-processor_test.go
@@ -0,0 +1,72 @@
+package dockertag
+
+import (
+	"bytes"
+	"github.com/mitchellh/packer/builder/docker"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"github.com/mitchellh/packer/post-processor/docker-import"
+	"testing"
+)
+
+func testConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"repository": "foo",
+		"tag":        "bar",
+	}
+}
+
+func testPP(t *testing.T) *PostProcessor {
+	var p PostProcessor
+	if err := p.Configure(testConfig()); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	return &p
+}
+
+func testUi() *packer.BasicUi {
+	return &packer.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	}
+}
+
+func TestPostProcessor_ImplementsPostProcessor(t *testing.T) {
+	var _ packer.PostProcessor = new(PostProcessor)
+}
+
+func TestPostProcessor_PostProcess(t *testing.T) {
+	driver := &docker.MockDriver{}
+	p := &PostProcessor{Driver: driver}
+	_, err := common.DecodeConfig(&p.config, testConfig())
+	if err != nil {
+		t.Fatalf("err %s", err)
+	}
+
+	artifact := &packer.MockArtifact{
+		BuilderIdValue: dockerimport.BuilderId,
+		IdValue:        "1234567890abcdef",
+	}
+
+	result, keep, err := p.PostProcess(testUi(), artifact)
+	if _, ok := result.(packer.Artifact); !ok {
+		t.Fatal("should be instance of Artifact")
+	}
+	if !keep {
+		t.Fatal("should keep")
+	}
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if !driver.TagImageCalled {
+		t.Fatal("should call TagImage")
+	}
+	if driver.TagImageImageId != "1234567890abcdef" {
+		t.Fatal("bad image id")
+	}
+	if driver.TagImageRepo != "foo:bar" {
+		t.Fatal("bad repo")
+	}
+}
diff --git a/post-processor/vagrant-cloud/artifact.go b/post-processor/vagrant-cloud/artifact.go
new file mode 100644
index 000000000..9f1d4f4bd
--- /dev/null
+++ b/post-processor/vagrant-cloud/artifact.go
@@ -0,0 +1,43 @@
+package vagrantcloud
+
+import (
+	"fmt"
+)
+
+const BuilderId = "pearkes.post-processor.vagrant-cloud"
+
+type Artifact struct {
+	Tag      string
+	Provider string
+}
+
+func NewArtifact(provider, tag string) *Artifact {
+	return &Artifact{
+		Tag:      tag,
+		Provider: provider,
+	}
+}
+
+func (*Artifact) BuilderId() string {
+	return BuilderId
+}
+
+func (a *Artifact) Files() []string {
+	return nil
+}
+
+func (a *Artifact) Id() string {
+	return ""
+}
+
+func (a *Artifact) String() string {
+	return fmt.Sprintf("'%s': %s", a.Provider, a.Tag)
+}
+
+func (*Artifact) State(name string) interface{} {
+	return nil
+}
+
+func (a *Artifact) Destroy() error {
+	return nil
+}
diff --git a/post-processor/vagrant-cloud/artifact_test.go b/post-processor/vagrant-cloud/artifact_test.go
new file mode 100644
index 000000000..b95e04511
--- /dev/null
+++ b/post-processor/vagrant-cloud/artifact_test.go
@@ -0,0 +1,14 @@
+package vagrantcloud
+
+import (
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func TestArtifact_ImplementsArtifact(t *testing.T) {
+	var raw interface{}
+	raw = &Artifact{}
+	if _, ok := raw.(packer.Artifact); !ok {
+		t.Fatalf("Artifact should be a Artifact")
+	}
+}
diff --git a/post-processor/vagrant-cloud/client.go b/post-processor/vagrant-cloud/client.go
new file mode 100644
index 000000000..104f13832
--- /dev/null
+++ b/post-processor/vagrant-cloud/client.go
@@ -0,0 +1,178 @@
+package vagrantcloud
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+)
+
+type VagrantCloudClient struct {
+	// The http client for communicating
+	client *http.Client
+
+	// The base URL of the API
+	BaseURL string
+
+	// Access token
+	AccessToken string
+}
+
+type VagrantCloudErrors struct {
+	Errors map[string][]string `json:"errors"`
+}
+
+func (v VagrantCloudErrors) FormatErrors() string {
+	errs := make([]string, 0)
+	for e := range v.Errors {
+		msg := fmt.Sprintf("%s %s", e, strings.Join(v.Errors[e], ","))
+		errs = append(errs, msg)
+	}
+	return strings.Join(errs, ". ")
+}
+
+func (v VagrantCloudClient) New(baseUrl string, token string) *VagrantCloudClient {
+	c := &VagrantCloudClient{
+		client: &http.Client{
+			Transport: &http.Transport{
+				Proxy: http.ProxyFromEnvironment,
+			},
+		},
+		BaseURL:     baseUrl,
+		AccessToken: token,
+	}
+	return c
+}
+
+func decodeBody(resp *http.Response, out interface{}) error {
+	defer resp.Body.Close()
+	dec := json.NewDecoder(resp.Body)
+	return dec.Decode(out)
+}
+
+// encodeBody is used to encode a request body
+func encodeBody(obj interface{}) (io.Reader, error) {
+	buf := bytes.NewBuffer(nil)
+	enc := json.NewEncoder(buf)
+	if err := enc.Encode(obj); err != nil {
+		return nil, err
+	}
+	return buf, nil
+}
+
+func (v VagrantCloudClient) Get(path string) (*http.Response, error) {
+	params := url.Values{}
+	params.Set("access_token", v.AccessToken)
+	reqUrl := fmt.Sprintf("%s/%s?%s", v.BaseURL, path, params.Encode())
+
+	// Scrub API key for logs
+	scrubbedUrl := strings.Replace(reqUrl, v.AccessToken, "ACCESS_TOKEN", -1)
+	log.Printf("Post-Processor Vagrant Cloud API GET: %s", scrubbedUrl)
+
+	req, err := http.NewRequest("GET", reqUrl, nil)
+	req.Header.Add("Content-Type", "application/json")
+	resp, err := v.client.Do(req)
+
+	log.Printf("Post-Processor Vagrant Cloud API Response: \n\n%s", resp)
+
+	return resp, err
+}
+
+func (v VagrantCloudClient) Delete(path string) (*http.Response, error) {
+	params := url.Values{}
+	params.Set("access_token", v.AccessToken)
+	reqUrl := fmt.Sprintf("%s/%s?%s", v.BaseURL, path, params.Encode())
+
+	// Scrub API key for logs
+	scrubbedUrl := strings.Replace(reqUrl, v.AccessToken, "ACCESS_TOKEN", -1)
+	log.Printf("Post-Processor Vagrant Cloud API DELETE: %s", scrubbedUrl)
+
+	req, err := http.NewRequest("DELETE", reqUrl, nil)
+	req.Header.Add("Content-Type", "application/json")
+	resp, err := v.client.Do(req)
+
+	log.Printf("Post-Processor Vagrant Cloud API Response: \n\n%s", resp)
+
+	return resp, err
+}
+
+func (v VagrantCloudClient) Upload(path string, url string) (*http.Response, error) {
+	file, err := os.Open(path)
+
+	if err != nil {
+		return nil, fmt.Errorf("Error opening file for upload: %s", err)
+	}
+
+	defer file.Close()
+
+	body := &bytes.Buffer{}
+
+	_, err = io.Copy(body, file)
+
+	if err != nil {
+		return nil, fmt.Errorf("Error uploading file: %s", err)
+	}
+
+	request, err := http.NewRequest("PUT", url, body)
+
+	if err != nil {
+		return nil, fmt.Errorf("Error preparing upload request: %s", err)
+	}
+
+	log.Printf("Post-Processor Vagrant Cloud API Upload: %s %s", path, url)
+
+	resp, err := v.client.Do(request)
+
+	log.Printf("Post-Processor Vagrant Cloud Upload Response: \n\n%s", resp)
+
+	return resp, err
+}
+
+func (v VagrantCloudClient) Post(path string, body interface{}) (*http.Response, error) {
+	params := url.Values{}
+	params.Set("access_token", v.AccessToken)
+	reqUrl := fmt.Sprintf("%s/%s?%s", v.BaseURL, path, params.Encode())
+
+	encBody, err := encodeBody(body)
+
+	if err != nil {
+		return nil, fmt.Errorf("Error encoding body for request: %s", err)
+	}
+
+	// Scrub API key for logs
+	scrubbedUrl := strings.Replace(reqUrl, v.AccessToken, "ACCESS_TOKEN", -1)
+	log.Printf("Post-Processor Vagrant Cloud API POST: %s. \n\n Body: %s", scrubbedUrl, encBody)
+
+	req, err := http.NewRequest("POST", reqUrl, encBody)
+	req.Header.Add("Content-Type", "application/json")
+
+	resp, err := v.client.Do(req)
+
+	log.Printf("Post-Processor Vagrant Cloud API Response: \n\n%s", resp)
+
+	return resp, err
+}
+
+func (v VagrantCloudClient) Put(path string) (*http.Response, error) {
+	params := url.Values{}
+	params.Set("access_token", v.AccessToken)
+	reqUrl := fmt.Sprintf("%s/%s?%s", v.BaseURL, path, params.Encode())
+
+	// Scrub API key for logs
+	scrubbedUrl := strings.Replace(reqUrl, v.AccessToken, "ACCESS_TOKEN", -1)
+	log.Printf("Post-Processor Vagrant Cloud API PUT: %s", scrubbedUrl)
+
+	req, err := http.NewRequest("PUT", reqUrl, nil)
+	req.Header.Add("Content-Type", "application/json")
+
+	resp, err := v.client.Do(req)
+
+	log.Printf("Post-Processor Vagrant Cloud API Response: \n\n%s", resp)
+
+	return resp, err
+}
diff --git a/post-processor/vagrant-cloud/post-processor.go b/post-processor/vagrant-cloud/post-processor.go
new file mode 100644
index 000000000..516bea5d9
--- /dev/null
+++ b/post-processor/vagrant-cloud/post-processor.go
@@ -0,0 +1,198 @@
+// vagrant_cloud implements the packer.PostProcessor interface and adds a
+// post-processor that uploads artifacts from the vagrant post-processor
+// to Vagrant Cloud (vagrantcloud.com) or manages self hosted boxes on the
+// Vagrant Cloud
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"strings"
+)
+
+const VAGRANT_CLOUD_URL = "https://vagrantcloud.com/api/v1"
+
+type Config struct {
+	common.PackerConfig `mapstructure:",squash"`
+
+	Tag                string `mapstructure:"box_tag"`
+	Version            string `mapstructure:"version"`
+	VersionDescription string `mapstructure:"version_description"`
+	NoRelease          bool   `mapstructure:"no_release"`
+
+	AccessToken     string `mapstructure:"access_token"`
+	VagrantCloudUrl string `mapstructure:"vagrant_cloud_url"`
+
+	BoxDownloadUrl string `mapstructure:"box_download_url"`
+
+	tpl *packer.ConfigTemplate
+}
+
+type boxDownloadUrlTemplate struct {
+	ArtifactId string
+	Provider   string
+}
+
+type PostProcessor struct {
+	config Config
+	client *VagrantCloudClient
+	runner multistep.Runner
+}
+
+func (p *PostProcessor) Configure(raws ...interface{}) error {
+	_, err := common.DecodeConfig(&p.config, raws...)
+	if err != nil {
+		return err
+	}
+
+	p.config.tpl, err = packer.NewConfigTemplate()
+	if err != nil {
+		return err
+	}
+	p.config.tpl.UserVars = p.config.PackerUserVars
+
+	// Default configuration
+	if p.config.VagrantCloudUrl == "" {
+		p.config.VagrantCloudUrl = VAGRANT_CLOUD_URL
+	}
+
+	// Accumulate any errors
+	errs := new(packer.MultiError)
+
+	// required configuration
+	templates := map[string]*string{
+		"box_tag":      &p.config.Tag,
+		"version":      &p.config.Version,
+		"access_token": &p.config.AccessToken,
+	}
+
+	for key, ptr := range templates {
+		if *ptr == "" {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("%s must be set", key))
+		}
+	}
+
+	// Template process
+	for key, ptr := range templates {
+		*ptr, err = p.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", key, err))
+		}
+	}
+
+	if len(errs.Errors) > 0 {
+		return errs
+	}
+
+	return nil
+}
+
+func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
+	// Only accepts input from the vagrant post-processor
+	if artifact.BuilderId() != "mitchellh.post-processor.vagrant" {
+		return nil, false, fmt.Errorf(
+			"Unknown artifact type, requires box from vagrant post-processor: %s", artifact.BuilderId())
+	}
+
+	// We assume that there is only one .box file to upload
+	if !strings.HasSuffix(artifact.Files()[0], ".box") {
+		return nil, false, fmt.Errorf(
+			"Unknown files in artifact from vagrant post-processor: %s", artifact.Files())
+	}
+
+	// create the HTTP client
+	p.client = VagrantCloudClient{}.New(p.config.VagrantCloudUrl, p.config.AccessToken)
+
+	// The name of the provider for vagrant cloud, and vagrant
+	providerName := providerFromBuilderName(artifact.Id())
+
+	boxDownloadUrl, err := p.config.tpl.Process(p.config.BoxDownloadUrl, &boxDownloadUrlTemplate{
+		ArtifactId: artifact.Id(),
+		Provider:   providerName,
+	})
+	if err != nil {
+		return nil, false, fmt.Errorf("Error processing box_download_url: %s", err)
+	}
+
+	// Set up the state
+	state := new(multistep.BasicStateBag)
+	state.Put("config", p.config)
+	state.Put("client", p.client)
+	state.Put("artifact", artifact)
+	state.Put("artifactFilePath", artifact.Files()[0])
+	state.Put("ui", ui)
+	state.Put("providerName", providerName)
+	state.Put("boxDownloadUrl", boxDownloadUrl)
+
+	// Build the steps
+	steps := []multistep.Step{}
+	if p.config.BoxDownloadUrl == "" {
+		steps = []multistep.Step{
+			new(stepVerifyBox),
+			new(stepCreateVersion),
+			new(stepCreateProvider),
+			new(stepPrepareUpload),
+			new(stepUpload),
+			new(stepVerifyUpload),
+			new(stepReleaseVersion),
+		}
+	} else {
+		steps = []multistep.Step{
+			new(stepVerifyBox),
+			new(stepCreateVersion),
+			new(stepCreateProvider),
+			new(stepReleaseVersion),
+		}
+	}
+
+	// Run the steps
+	if p.config.PackerDebug {
+		p.runner = &multistep.DebugRunner{
+			Steps:   steps,
+			PauseFn: common.MultistepDebugFn(ui),
+		}
+	} else {
+		p.runner = &multistep.BasicRunner{Steps: steps}
+	}
+
+	p.runner.Run(state)
+
+	// If there was an error, return that
+	if rawErr, ok := state.GetOk("error"); ok {
+		return nil, false, rawErr.(error)
+	}
+
+	return NewArtifact(providerName, p.config.Tag), true, nil
+}
+
+// Runs a cleanup if the post processor fails to upload
+func (p *PostProcessor) Cancel() {
+	if p.runner != nil {
+		log.Println("Cancelling the step runner...")
+		p.runner.Cancel()
+	}
+}
+
+// converts a packer builder name to the corresponding vagrant
+// provider
+func providerFromBuilderName(name string) string {
+	switch name {
+	case "aws":
+		return "aws"
+	case "digitalocean":
+		return "digitalocean"
+	case "virtualbox":
+		return "virtualbox"
+	case "vmware":
+		return "vmware_desktop"
+	case "parallels":
+		return "parallels"
+	default:
+		return name
+	}
+}
diff --git a/post-processor/vagrant-cloud/post-processor_test.go b/post-processor/vagrant-cloud/post-processor_test.go
new file mode 100644
index 000000000..ff99314c4
--- /dev/null
+++ b/post-processor/vagrant-cloud/post-processor_test.go
@@ -0,0 +1,59 @@
+package vagrantcloud
+
+import (
+	"bytes"
+	"github.com/mitchellh/packer/packer"
+	"testing"
+)
+
+func testGoodConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"access_token":        "foo",
+		"version_description": "bar",
+		"box_tag":             "hashicorp/precise64",
+		"version":             "0.5",
+	}
+}
+
+func testBadConfig() map[string]interface{} {
+	return map[string]interface{}{
+		"access_token":        "foo",
+		"box_tag":             "baz",
+		"version_description": "bar",
+	}
+}
+
+func TestPostProcessor_Configure_Good(t *testing.T) {
+	var p PostProcessor
+	if err := p.Configure(testGoodConfig()); err != nil {
+		t.Fatalf("err: %s", err)
+	}
+}
+
+func TestPostProcessor_Configure_Bad(t *testing.T) {
+	var p PostProcessor
+	if err := p.Configure(testBadConfig()); err == nil {
+		t.Fatalf("should have err")
+	}
+}
+
+func testUi() *packer.BasicUi {
+	return &packer.BasicUi{
+		Reader: new(bytes.Buffer),
+		Writer: new(bytes.Buffer),
+	}
+}
+
+func TestPostProcessor_ImplementsPostProcessor(t *testing.T) {
+	var _ packer.PostProcessor = new(PostProcessor)
+}
+
+func TestproviderFromBuilderName(t *testing.T) {
+	if providerFromBuilderName("foobar") != "foobar" {
+		t.Fatal("should copy unknown provider")
+	}
+
+	if providerFromBuilderName("vmware") != "vmware_desktop" {
+		t.Fatal("should convert provider")
+	}
+}
diff --git a/post-processor/vagrant-cloud/step_create_provider.go b/post-processor/vagrant-cloud/step_create_provider.go
new file mode 100644
index 000000000..c2d6772bd
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_create_provider.go
@@ -0,0 +1,97 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+type Provider struct {
+	Name        string `json:"name"`
+	Url         string `json:"url,omitempty"`
+	HostedToken string `json:"hosted_token,omitempty"`
+	UploadUrl   string `json:"upload_url,omitempty"`
+}
+
+type stepCreateProvider struct {
+	name string // the name of the provider
+}
+
+func (s *stepCreateProvider) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	box := state.Get("box").(*Box)
+	version := state.Get("version").(*Version)
+	providerName := state.Get("providerName").(string)
+	downloadUrl := state.Get("boxDownloadUrl").(string)
+
+	path := fmt.Sprintf("box/%s/version/%v/providers", box.Tag, version.Number)
+
+	provider := &Provider{Name: providerName}
+
+	if downloadUrl != "" {
+		provider.Url = downloadUrl
+	}
+
+	// Wrap the provider in a provider object for the API
+	wrapper := make(map[string]interface{})
+	wrapper["provider"] = provider
+
+	ui.Say(fmt.Sprintf("Creating provider: %s", providerName))
+
+	resp, err := client.Post(path, wrapper)
+
+	if err != nil || (resp.StatusCode != 200) {
+		cloudErrors := &VagrantCloudErrors{}
+		err = decodeBody(resp, cloudErrors)
+		state.Put("error", fmt.Errorf("Error creating provider: %s", cloudErrors.FormatErrors()))
+		return multistep.ActionHalt
+	}
+
+	if err = decodeBody(resp, provider); err != nil {
+		state.Put("error", fmt.Errorf("Error parsing provider response: %s", err))
+		return multistep.ActionHalt
+	}
+
+	// Save the name for cleanup
+	s.name = provider.Name
+
+	state.Put("provider", provider)
+
+	return multistep.ActionContinue
+}
+
+func (s *stepCreateProvider) Cleanup(state multistep.StateBag) {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	box := state.Get("box").(*Box)
+	version := state.Get("version").(*Version)
+
+	// If we didn't save the provider name, it likely doesn't exist
+	if s.name == "" {
+		ui.Say("Cleaning up provider")
+		ui.Message("Provider was not created, not deleting")
+		return
+	}
+
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	_, halted := state.GetOk(multistep.StateHalted)
+
+	// Return if we didn't cancel or halt, and thus need
+	// no cleanup
+	if !cancelled && !halted {
+		return
+	}
+
+	ui.Say("Cleaning up provider")
+	ui.Message(fmt.Sprintf("Deleting provider: %s", s.name))
+
+	path := fmt.Sprintf("box/%s/version/%v/provider/%s", box.Tag, version.Number, s.name)
+
+	// No need for resp from the cleanup DELETE
+	_, err := client.Delete(path)
+
+	if err != nil {
+		ui.Error(fmt.Sprintf("Error destroying provider: %s", err))
+	}
+}
diff --git a/post-processor/vagrant-cloud/step_create_version.go b/post-processor/vagrant-cloud/step_create_version.go
new file mode 100644
index 000000000..8108577cc
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_create_version.go
@@ -0,0 +1,97 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+type Version struct {
+	Version     string `json:"version"`
+	Description string `json:"description,omitempty"`
+	Number      uint   `json:"number,omitempty"`
+}
+
+type stepCreateVersion struct {
+	number uint // number of the version, if needed in cleanup
+}
+
+func (s *stepCreateVersion) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(Config)
+	box := state.Get("box").(*Box)
+
+	ui.Say(fmt.Sprintf("Creating version: %s", config.Version))
+
+	if hasVersion, v := box.HasVersion(config.Version); hasVersion {
+		ui.Message(fmt.Sprintf("Version exists, skipping creation"))
+		state.Put("version", v)
+		return multistep.ActionContinue
+	}
+
+	path := fmt.Sprintf("box/%s/versions", box.Tag)
+
+	version := &Version{Version: config.Version, Description: config.VersionDescription}
+
+	// Wrap the version in a version object for the API
+	wrapper := make(map[string]interface{})
+	wrapper["version"] = version
+
+	resp, err := client.Post(path, wrapper)
+
+	if err != nil || (resp.StatusCode != 200) {
+		cloudErrors := &VagrantCloudErrors{}
+		err = decodeBody(resp, cloudErrors)
+		state.Put("error", fmt.Errorf("Error creating version: %s", cloudErrors.FormatErrors()))
+		return multistep.ActionHalt
+	}
+
+	if err = decodeBody(resp, version); err != nil {
+		state.Put("error", fmt.Errorf("Error parsing version response: %s", err))
+		return multistep.ActionHalt
+	}
+
+	// Save the number for cleanup
+	s.number = version.Number
+
+	state.Put("version", version)
+
+	return multistep.ActionContinue
+}
+
+func (s *stepCreateVersion) Cleanup(state multistep.StateBag) {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(Config)
+	box := state.Get("box").(*Box)
+
+	// If we didn't save the version number, it likely doesn't exist or
+	// already existed
+	if s.number == 0 {
+		ui.Message("Version was not created or previously existed, not deleting")
+		return
+	}
+
+	_, cancelled := state.GetOk(multistep.StateCancelled)
+	_, halted := state.GetOk(multistep.StateHalted)
+
+	// Return if we didn't cancel or halt, and thus need
+	// no cleanup
+	if !cancelled && !halted {
+		return
+	}
+
+	path := fmt.Sprintf("box/%s/version/%v", box.Tag, s.number)
+
+	ui.Say("Cleaning up version")
+	ui.Message(fmt.Sprintf("Deleting version: %s", config.Version))
+
+	// No need for resp from the cleanup DELETE
+	_, err := client.Delete(path)
+
+	if err != nil {
+		ui.Error(fmt.Sprintf("Error destroying version: %s", err))
+	}
+
+}
diff --git a/post-processor/vagrant-cloud/step_prepare_upload.go b/post-processor/vagrant-cloud/step_prepare_upload.go
new file mode 100644
index 000000000..5c82d02c3
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_prepare_upload.go
@@ -0,0 +1,54 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+type Upload struct {
+	Token      string `json:"token"`
+	UploadPath string `json:"upload_path"`
+}
+
+type stepPrepareUpload struct {
+}
+
+func (s *stepPrepareUpload) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	box := state.Get("box").(*Box)
+	version := state.Get("version").(*Version)
+	provider := state.Get("provider").(*Provider)
+	artifactFilePath := state.Get("artifactFilePath").(string)
+
+	path := fmt.Sprintf("box/%s/version/%v/provider/%s/upload", box.Tag, version.Number, provider.Name)
+	upload := &Upload{}
+
+	ui.Say(fmt.Sprintf("Preparing upload of box: %s", artifactFilePath))
+
+	resp, err := client.Get(path)
+
+	if err != nil || (resp.StatusCode != 200) {
+		cloudErrors := &VagrantCloudErrors{}
+		err = decodeBody(resp, cloudErrors)
+		state.Put("error", fmt.Errorf("Error preparing upload: %s", cloudErrors.FormatErrors()))
+		return multistep.ActionHalt
+	}
+
+	if err = decodeBody(resp, upload); err != nil {
+		state.Put("error", fmt.Errorf("Error parsing upload response: %s", err))
+		return multistep.ActionHalt
+	}
+
+	ui.Message(fmt.Sprintf("Box upload prepared with token %s", upload.Token))
+
+	// Save the upload details to the state
+	state.Put("upload", upload)
+
+	return multistep.ActionContinue
+}
+
+func (s *stepPrepareUpload) Cleanup(state multistep.StateBag) {
+	// No cleanup
+}
diff --git a/post-processor/vagrant-cloud/step_release_version.go b/post-processor/vagrant-cloud/step_release_version.go
new file mode 100644
index 000000000..dab417d00
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_release_version.go
@@ -0,0 +1,49 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"strings"
+)
+
+type stepReleaseVersion struct {
+}
+
+func (s *stepReleaseVersion) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	box := state.Get("box").(*Box)
+	version := state.Get("version").(*Version)
+	config := state.Get("config").(Config)
+
+	ui.Say(fmt.Sprintf("Releasing version: %s", version.Version))
+
+	if config.NoRelease {
+		ui.Message("Not releasing version due to configuration")
+		return multistep.ActionContinue
+	}
+
+	path := fmt.Sprintf("box/%s/version/%v/release", box.Tag, version.Number)
+
+	resp, err := client.Put(path)
+
+	if err != nil || (resp.StatusCode != 200) {
+		cloudErrors := &VagrantCloudErrors{}
+		err = decodeBody(resp, cloudErrors)
+		if strings.Contains(cloudErrors.FormatErrors(), "already been released") {
+			ui.Message("Not releasing version, already released")
+			return multistep.ActionContinue
+		}
+		state.Put("error", fmt.Errorf("Error releasing version: %s", cloudErrors.FormatErrors()))
+		return multistep.ActionHalt
+	}
+
+	ui.Message(fmt.Sprintf("Version successfully released and available"))
+
+	return multistep.ActionContinue
+}
+
+func (s *stepReleaseVersion) Cleanup(state multistep.StateBag) {
+	// No cleanup
+}
diff --git a/post-processor/vagrant-cloud/step_upload.go b/post-processor/vagrant-cloud/step_upload.go
new file mode 100644
index 000000000..f82f125f8
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_upload.go
@@ -0,0 +1,37 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+type stepUpload struct {
+}
+
+func (s *stepUpload) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	upload := state.Get("upload").(*Upload)
+	artifactFilePath := state.Get("artifactFilePath").(string)
+	url := upload.UploadPath
+
+	ui.Say(fmt.Sprintf("Uploading box: %s", artifactFilePath))
+
+	ui.Message("Depending on your internet connection and the size of the box, this may take some time")
+
+	resp, err := client.Upload(artifactFilePath, url)
+
+	if err != nil || (resp.StatusCode != 200) {
+		state.Put("error", fmt.Errorf("Error uploading Box: %s", err))
+		return multistep.ActionHalt
+	}
+
+	ui.Message("Box succesfully uploaded")
+
+	return multistep.ActionContinue
+}
+
+func (s *stepUpload) Cleanup(state multistep.StateBag) {
+	// No cleanup
+}
diff --git a/post-processor/vagrant-cloud/step_verify_box.go b/post-processor/vagrant-cloud/step_verify_box.go
new file mode 100644
index 000000000..cc3f48b85
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_verify_box.go
@@ -0,0 +1,71 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+)
+
+type Box struct {
+	Tag      string     `json:"tag"`
+	Versions []*Version `json:"versions"`
+}
+
+func (b *Box) HasVersion(version string) (bool, *Version) {
+	for _, v := range b.Versions {
+		if v.Version == version {
+			return true, v
+		}
+	}
+	return false, nil
+}
+
+type stepVerifyBox struct {
+}
+
+func (s *stepVerifyBox) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	config := state.Get("config").(Config)
+
+	ui.Say(fmt.Sprintf("Verifying box is accessible: %s", config.Tag))
+
+	path := fmt.Sprintf("box/%s", config.Tag)
+	resp, err := client.Get(path)
+
+	if err != nil {
+		state.Put("error", fmt.Errorf("Error retrieving box: %s", err))
+		return multistep.ActionHalt
+	}
+
+	if resp.StatusCode != 200 {
+		cloudErrors := &VagrantCloudErrors{}
+		err = decodeBody(resp, cloudErrors)
+		state.Put("error", fmt.Errorf("Error retrieving box: %s", cloudErrors.FormatErrors()))
+		return multistep.ActionHalt
+	}
+
+	box := &Box{}
+
+	if err = decodeBody(resp, box); err != nil {
+		state.Put("error", fmt.Errorf("Error parsing box response: %s", err))
+		return multistep.ActionHalt
+	}
+
+	if box.Tag != config.Tag {
+		state.Put("error", fmt.Errorf("Could not verify box: %s", config.Tag))
+		return multistep.ActionHalt
+	}
+
+	ui.Message("Box accessible and matches tag")
+
+	// Keep the box in state for later
+	state.Put("box", box)
+
+	// Box exists and is accessible
+	return multistep.ActionContinue
+}
+
+func (s *stepVerifyBox) Cleanup(state multistep.StateBag) {
+	// no cleanup needed
+}
diff --git a/post-processor/vagrant-cloud/step_verify_upload.go b/post-processor/vagrant-cloud/step_verify_upload.go
new file mode 100644
index 000000000..120bd647d
--- /dev/null
+++ b/post-processor/vagrant-cloud/step_verify_upload.go
@@ -0,0 +1,103 @@
+package vagrantcloud
+
+import (
+	"fmt"
+	"github.com/mitchellh/multistep"
+	"github.com/mitchellh/packer/packer"
+	"log"
+	"time"
+)
+
+type stepVerifyUpload struct {
+}
+
+func (s *stepVerifyUpload) Run(state multistep.StateBag) multistep.StepAction {
+	client := state.Get("client").(*VagrantCloudClient)
+	ui := state.Get("ui").(packer.Ui)
+	box := state.Get("box").(*Box)
+	version := state.Get("version").(*Version)
+	upload := state.Get("upload").(*Upload)
+	provider := state.Get("provider").(*Provider)
+
+	path := fmt.Sprintf("box/%s/version/%v/provider/%s", box.Tag, version.Number, provider.Name)
+
+	providerCheck := &Provider{}
+
+	ui.Say(fmt.Sprintf("Verifying provider upload: %s", provider.Name))
+
+	done := make(chan struct{})
+	defer close(done)
+
+	result := make(chan error, 1)
+
+	go func() {
+		attempts := 0
+		for {
+			attempts += 1
+
+			log.Printf("Checking token match for provider.. (attempt: %d)", attempts)
+
+			resp, err := client.Get(path)
+
+			if err != nil || (resp.StatusCode != 200) {
+				cloudErrors := &VagrantCloudErrors{}
+				err = decodeBody(resp, cloudErrors)
+				err = fmt.Errorf("Error retrieving provider: %s", cloudErrors.FormatErrors())
+				result <- err
+				return
+			}
+
+			if err = decodeBody(resp, providerCheck); err != nil {
+				err = fmt.Errorf("Error parsing provider response: %s", err)
+				result <- err
+				return
+			}
+
+			if err != nil {
+				result <- err
+				return
+			}
+
+			if upload.Token == providerCheck.HostedToken {
+				// success!
+				result <- nil
+				return
+			}
+
+			// Wait 3 seconds in between
+			time.Sleep(3 * time.Second)
+
+			// Verify we shouldn't exit
+			select {
+			case <-done:
+				// We finished, so just exit the goroutine
+				return
+			default:
+				// Keep going
+			}
+		}
+	}()
+
+	ui.Message("Waiting for upload token match")
+	log.Printf("Waiting for up to 600 seconds for provider hosted token to match %s", upload.Token)
+
+	select {
+	case err := <-result:
+		if err != nil {
+			state.Put("error", err)
+			return multistep.ActionHalt
+		}
+
+		ui.Message(fmt.Sprintf("Upload succesfully verified with token %s", providerCheck.HostedToken))
+		log.Printf("Box succesfully verified %s == %s", upload.Token, providerCheck.HostedToken)
+
+		return multistep.ActionContinue
+	case <-time.After(600 * time.Second):
+		state.Put("error", fmt.Errorf("Timeout while waiting to for upload to verify token '%s'", upload.Token))
+		return multistep.ActionHalt
+	}
+}
+
+func (s *stepVerifyUpload) Cleanup(state multistep.StateBag) {
+	// No cleanup
+}
diff --git a/post-processor/vagrant/artifact.go b/post-processor/vagrant/artifact.go
index 1b4885b52..5974e9901 100644
--- a/post-processor/vagrant/artifact.go
+++ b/post-processor/vagrant/artifact.go
@@ -28,13 +28,17 @@ func (a *Artifact) Files() []string {
 }
 
 func (a *Artifact) Id() string {
-	return ""
+	return a.Provider
 }
 
 func (a *Artifact) String() string {
 	return fmt.Sprintf("'%s' provider box: %s", a.Provider, a.Path)
 }
 
+func (a *Artifact) State(name string) interface{} {
+	return nil
+}
+
 func (a *Artifact) Destroy() error {
 	return os.Remove(a.Path)
 }
diff --git a/post-processor/vagrant/artifact_test.go b/post-processor/vagrant/artifact_test.go
index 5c711dad2..6e16285a2 100644
--- a/post-processor/vagrant/artifact_test.go
+++ b/post-processor/vagrant/artifact_test.go
@@ -12,3 +12,10 @@ func TestArtifact_ImplementsArtifact(t *testing.T) {
 		t.Fatalf("Artifact should be a Artifact")
 	}
 }
+
+func TestArtifact_Id(t *testing.T) {
+	artifact := NewArtifact("vmware", "./")
+	if artifact.Id() != "vmware" {
+		t.Fatalf("should return name as Id")
+	}
+}
diff --git a/post-processor/vagrant/hyperv.go b/post-processor/vagrant/hyperv.go
new file mode 100644
index 000000000..d5fa0ce52
--- /dev/null
+++ b/post-processor/vagrant/hyperv.go
@@ -0,0 +1,30 @@
+package vagrant
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+	"path/filepath"
+)
+
+type HypervProvider struct{}
+
+func (p *HypervProvider) KeepInputArtifact() bool {
+	return false
+}
+
+func (p *HypervProvider) Process(ui packer.Ui, artifact packer.Artifact, dir string) (vagrantfile string, metadata map[string]interface{}, err error) {
+	// Create the metadata
+	metadata = map[string]interface{}{"provider": "hyperv"}
+
+	// Copy all of the original contents into the temporary directory
+	for _, path := range artifact.Files() {
+		ui.Message(fmt.Sprintf("Copying: %s", path))
+
+		dstPath := filepath.Join(dir, filepath.Base(path))
+		if err = CopyContents(dstPath, path); err != nil {
+			return
+		}
+	}
+
+	return
+}
diff --git a/post-processor/vagrant/libvirt.go b/post-processor/vagrant/libvirt.go
new file mode 100644
index 000000000..39a4f18b0
--- /dev/null
+++ b/post-processor/vagrant/libvirt.go
@@ -0,0 +1,64 @@
+package vagrant
+
+import (
+	"fmt"
+	"github.com/mitchellh/packer/packer"
+	"path/filepath"
+	"strings"
+)
+
+type LibVirtProvider struct{}
+
+func (p *LibVirtProvider) KeepInputArtifact() bool {
+	return false
+}
+func (p *LibVirtProvider) Process(ui packer.Ui, artifact packer.Artifact, dir string) (vagrantfile string, metadata map[string]interface{}, err error) {
+	diskName := artifact.State("diskName").(string)
+
+	// Copy the disk image into the temporary directory (as box.img)
+	for _, path := range artifact.Files() {
+		if strings.HasSuffix(path, "/"+diskName) {
+			ui.Message(fmt.Sprintf("Copying from artifact: %s", path))
+			dstPath := filepath.Join(dir, "box.img")
+			if err = CopyContents(dstPath, path); err != nil {
+				return
+			}
+		}
+	}
+
+	format := artifact.State("diskType").(string)
+	origSize := artifact.State("diskSize").(uint64)
+	size := origSize / 1024 // In MB, want GB
+	if origSize%1024 > 0 {
+		// Make sure we don't make the size smaller
+		size++
+	}
+	domainType := artifact.State("domainType").(string)
+
+	// Convert domain type to libvirt driver
+	var driver string
+	switch domainType {
+	case "kvm", "qemu":
+		driver = domainType
+	default:
+		return "", nil, fmt.Errorf("Unknown libvirt domain type: %s", domainType)
+	}
+
+	// Create the metadata
+	metadata = map[string]interface{}{
+		"provider":     "libvirt",
+		"format":       format,
+		"virtual_size": size,
+	}
+
+	vagrantfile = fmt.Sprintf(libvirtVagrantfile, driver)
+	return
+}
+
+var libvirtVagrantfile = `
+Vagrant.configure("2") do |config|
+  config.vm.provider :libvirt do |libvirt|
+    libvirt.driver = "%s"
+  end
+end
+`
diff --git a/post-processor/vagrant/parallels.go b/post-processor/vagrant/parallels.go
new file mode 100644
index 000000000..a6ee26b95
--- /dev/null
+++ b/post-processor/vagrant/parallels.go
@@ -0,0 +1,58 @@
+package vagrant
+
+import (
+	"fmt"
+	"path/filepath"
+	"regexp"
+
+	"github.com/mitchellh/packer/packer"
+)
+
+// These are the extensions of files and directories that are unnecessary for the function
+// of a Parallels virtual machine.
+var UnnecessaryFilesPatterns = []string{"\\.log$", "\\.backup$", "\\.Backup$", "\\.app/"}
+
+type ParallelsProvider struct{}
+
+func (p *ParallelsProvider) KeepInputArtifact() bool {
+	return false
+}
+
+func (p *ParallelsProvider) Process(ui packer.Ui, artifact packer.Artifact, dir string) (vagrantfile string, metadata map[string]interface{}, err error) {
+	// Create the metadata
+	metadata = map[string]interface{}{"provider": "parallels"}
+
+	// Copy all of the original contents into the temporary directory
+	for _, path := range artifact.Files() {
+		// If the file isn't critical to the function of the
+		// virtual machine, we get rid of it.
+		unnecessary := false
+		for _, unnecessaryPat := range UnnecessaryFilesPatterns {
+			if matched, _ := regexp.MatchString(unnecessaryPat, path); matched {
+				unnecessary = true
+				break
+			}
+		}
+		if unnecessary {
+			continue
+		}
+
+		tmpPath := filepath.ToSlash(path)
+		pathRe := regexp.MustCompile(`^(.+?)([^/]+\.pvm/.+?)$`)
+		matches := pathRe.FindStringSubmatch(tmpPath)
+		var pvmPath string
+		if matches != nil {
+			pvmPath = filepath.FromSlash(matches[2])
+		} else {
+			continue // Just copy a pvm
+		}
+		dstPath := filepath.Join(dir, pvmPath)
+
+		ui.Message(fmt.Sprintf("Copying: %s", path))
+		if err = CopyContents(dstPath, path); err != nil {
+			return
+		}
+	}
+
+	return
+}
diff --git a/post-processor/vagrant/parallels_test.go b/post-processor/vagrant/parallels_test.go
new file mode 100644
index 000000000..093680f82
--- /dev/null
+++ b/post-processor/vagrant/parallels_test.go
@@ -0,0 +1,9 @@
+package vagrant
+
+import (
+	"testing"
+)
+
+func TestParallelsProvider_impl(t *testing.T) {
+	var _ Provider = new(ParallelsProvider)
+}
diff --git a/post-processor/vagrant/post-processor.go b/post-processor/vagrant/post-processor.go
index e0076febf..e43690e0c 100644
--- a/post-processor/vagrant/post-processor.go
+++ b/post-processor/vagrant/post-processor.go
@@ -21,6 +21,9 @@ var builtins = map[string]string{
 	"mitchellh.virtualbox":      "virtualbox",
 	"mitchellh.vmware":          "vmware",
 	"pearkes.digitalocean":      "digitalocean",
+	"packer.parallels":          "parallels",
+	"MSOpenTech.hyperv":         "hyperv",
+	"transcend.qemu":            "libvirt",
 }
 
 type Config struct {
@@ -62,19 +65,7 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 	return nil
 }
 
-func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
-	name, ok := builtins[artifact.BuilderId()]
-	if !ok {
-		return nil, false, fmt.Errorf(
-			"Unknown artifact type, can't build box: %s", artifact.BuilderId())
-	}
-
-	provider := providerForName(name)
-	if provider == nil {
-		// This shouldn't happen since we hard code all of these ourselves
-		panic(fmt.Sprintf("bad provider name: %s", name))
-	}
-
+func (p *PostProcessor) PostProcessProvider(name string, provider Provider, ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
 	config := p.configs[""]
 	if specificConfig, ok := p.configs[name]; ok {
 		config = specificConfig
@@ -122,9 +113,14 @@ func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (pac
 	// Write our Vagrantfile
 	var customVagrantfile string
 	if config.VagrantfileTemplate != "" {
+		vagrantfilePath, err := config.tpl.Process(config.VagrantfileTemplate, nil)
+		if err != nil {
+			return nil, false, err
+		}
+
 		ui.Message(fmt.Sprintf(
-			"Using custom Vagrantfile: %s", config.VagrantfileTemplate))
-		customBytes, err := ioutil.ReadFile(config.VagrantfileTemplate)
+			"Using custom Vagrantfile: %s", vagrantfilePath))
+		customBytes, err := ioutil.ReadFile(vagrantfilePath)
 		if err != nil {
 			return nil, false, err
 		}
@@ -155,6 +151,23 @@ func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (pac
 	return NewArtifact(name, outputPath), provider.KeepInputArtifact(), nil
 }
 
+func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (packer.Artifact, bool, error) {
+
+	name, ok := builtins[artifact.BuilderId()]
+	if !ok {
+		return nil, false, fmt.Errorf(
+			"Unknown artifact type, can't build box: %s", artifact.BuilderId())
+	}
+
+	provider := providerForName(name)
+	if provider == nil {
+		// This shouldn't happen since we hard code all of these ourselves
+		panic(fmt.Sprintf("bad provider name: %s", name))
+	}
+
+	return p.PostProcessProvider(name, provider, ui, artifact)
+}
+
 func (p *PostProcessor) configureSingle(config *Config, raws ...interface{}) error {
 	md, err := common.DecodeConfig(config, raws...)
 	if err != nil {
@@ -216,6 +229,12 @@ func providerForName(name string) Provider {
 		return new(VBoxProvider)
 	case "vmware":
 		return new(VMwareProvider)
+	case "parallels":
+		return new(ParallelsProvider)
+	case "hyperv":
+		return new(HypervProvider)
+	case "libvirt":
+		return new(LibVirtProvider)
 	default:
 		return nil
 	}
diff --git a/post-processor/vagrant/util.go b/post-processor/vagrant/util.go
index 3cce14a82..a9e745fe6 100644
--- a/post-processor/vagrant/util.go
+++ b/post-processor/vagrant/util.go
@@ -21,6 +21,14 @@ func CopyContents(dst, src string) error {
 	}
 	defer srcF.Close()
 
+	dstDir, _ := filepath.Split(dst)
+	if dstDir != "" {
+		err := os.MkdirAll(dstDir, os.ModePerm)
+		if err != nil {
+			return err
+		}
+	}
+
 	dstF, err := os.Create(dst)
 	if err != nil {
 		return err
@@ -122,12 +130,16 @@ func DirToBox(dst, dir string, ui packer.Ui, level int) error {
 
 // WriteMetadata writes the "metadata.json" file for a Vagrant box.
 func WriteMetadata(dir string, contents interface{}) error {
-	f, err := os.Create(filepath.Join(dir, "metadata.json"))
-	if err != nil {
-		return err
-	}
-	defer f.Close()
+	if _, err := os.Stat(filepath.Join(dir, "metadata.json")); os.IsNotExist(err) {
+		f, err := os.Create(filepath.Join(dir, "metadata.json"))
+		if err != nil {
+			return err
+		}
+		defer f.Close()
 
-	enc := json.NewEncoder(f)
-	return enc.Encode(contents)
+		enc := json.NewEncoder(f)
+		return enc.Encode(contents)
+	}
+
+	return nil
 }
diff --git a/post-processor/vsphere/post-processor.go b/post-processor/vsphere/post-processor.go
index 29d0f32bc..81dc27f87 100644
--- a/post-processor/vsphere/post-processor.go
+++ b/post-processor/vsphere/post-processor.go
@@ -5,6 +5,8 @@ import (
 	"fmt"
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
+	"log"
+	"net/url"
 	"os/exec"
 	"strings"
 )
@@ -61,26 +63,31 @@ func (p *PostProcessor) Configure(raws ...interface{}) error {
 			errs, fmt.Errorf("ovftool not found: %s", err))
 	}
 
+	// First define all our templatable parameters that are _required_
 	templates := map[string]*string{
 		"cluster":       &p.config.Cluster,
 		"datacenter":    &p.config.Datacenter,
-		"datastore":     &p.config.Datastore,
 		"diskmode":      &p.config.DiskMode,
 		"host":          &p.config.Host,
-		"vm_network":    &p.config.VMNetwork,
 		"password":      &p.config.Password,
 		"resource_pool": &p.config.ResourcePool,
 		"username":      &p.config.Username,
-		"vm_folder":     &p.config.VMFolder,
 		"vm_name":       &p.config.VMName,
 	}
-
 	for key, ptr := range templates {
 		if *ptr == "" {
 			errs = packer.MultiErrorAppend(
 				errs, fmt.Errorf("%s must be set", key))
 		}
+	}
 
+	// Then define the ones that are optional
+	templates["datastore"] = &p.config.Datastore
+	templates["vm_network"] = &p.config.VMNetwork
+	templates["vm_folder"] = &p.config.VMFolder
+
+	// Template process
+	for key, ptr := range templates {
 		*ptr, err = p.config.tpl.Process(*ptr, nil)
 		if err != nil {
 			errs = packer.MultiErrorAppend(
@@ -121,8 +128,8 @@ func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (pac
 		fmt.Sprintf("--network=%s", p.config.VMNetwork),
 		fmt.Sprintf("--vmFolder=%s", p.config.VMFolder),
 		fmt.Sprintf("%s", vmx),
-		fmt.Sprintf("vi://%s:%s@%s/%s/host/%s/Resources/%s",
-			p.config.Username,
+		fmt.Sprintf("vi://%s:%s@%s/%s/host/%s/Resources/%s/",
+			url.QueryEscape(p.config.Username),
 			p.config.Password,
 			p.config.Host,
 			p.config.Datacenter,
@@ -132,6 +139,7 @@ func (p *PostProcessor) PostProcess(ui packer.Ui, artifact packer.Artifact) (pac
 
 	ui.Message(fmt.Sprintf("Uploading %s to vSphere", vmx))
 	var out bytes.Buffer
+	log.Printf("Starting ovftool with parameters: %s", strings.Join(args, " "))
 	cmd := exec.Command("ovftool", args...)
 	cmd.Stdout = &out
 	if err := cmd.Run(); err != nil {
diff --git a/provisioner/ansible-local/provisioner.go b/provisioner/ansible-local/provisioner.go
index 81d86cbd6..3ab37c086 100644
--- a/provisioner/ansible-local/provisioner.go
+++ b/provisioner/ansible-local/provisioner.go
@@ -2,11 +2,13 @@ package ansiblelocal
 
 import (
 	"fmt"
-	"github.com/mitchellh/packer/common"
-	"github.com/mitchellh/packer/packer"
+	"io/ioutil"
 	"os"
 	"path/filepath"
 	"strings"
+
+	"github.com/mitchellh/packer/common"
+	"github.com/mitchellh/packer/packer"
 )
 
 const DefaultStagingDir = "/tmp/packer-provisioner-ansible-local"
@@ -27,6 +29,9 @@ type Config struct {
 	// Path to host_vars directory
 	HostVars string `mapstructure:"host_vars"`
 
+	// The playbook dir to upload.
+	PlaybookDir string `mapstructure:"playbook_dir"`
+
 	// The main playbook file to execute.
 	PlaybookFile string `mapstructure:"playbook_file"`
 
@@ -66,7 +71,7 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 
 	// Defaults
 	if p.config.Command == "" {
-		p.config.Command = "ansible-playbook"
+		p.config.Command = "ANSIBLE_FORCE_COLOR=1 PYTHONUNBUFFERED=1 ansible-playbook"
 	}
 
 	if p.config.StagingDir == "" {
@@ -79,6 +84,7 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 		"group_vars":     &p.config.GroupVars,
 		"host_vars":      &p.config.HostVars,
 		"playbook_file":  &p.config.PlaybookFile,
+		"playbook_dir":   &p.config.PlaybookDir,
 		"staging_dir":    &p.config.StagingDir,
 		"inventory_file": &p.config.InventoryFile,
 	}
@@ -123,6 +129,13 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 		}
 	}
 
+	// Check that the playbook_dir directory exists, if configured
+	if len(p.config.PlaybookDir) > 0 {
+		if err := validateDirConfig(p.config.PlaybookDir, "playbook_dir"); err != nil {
+			errs = packer.MultiErrorAppend(errs, err)
+		}
+	}
+
 	// Check that the group_vars directory exists, if configured
 	if len(p.config.GroupVars) > 0 {
 		if err := validateDirConfig(p.config.GroupVars, "group_vars"); err != nil {
@@ -158,9 +171,16 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 	ui.Say("Provisioning with Ansible...")
 
-	ui.Message("Creating Ansible staging directory...")
-	if err := p.createDir(ui, comm, p.config.StagingDir); err != nil {
-		return fmt.Errorf("Error creating staging directory: %s", err)
+	if len(p.config.PlaybookDir) > 0 {
+		ui.Message("Uploading Playbook directory to Ansible staging directory...")
+		if err := p.uploadDir(ui, comm, p.config.StagingDir, p.config.PlaybookDir); err != nil {
+			return fmt.Errorf("Error uploading playbook_dir directory: %s", err)
+		}
+	} else {
+		ui.Message("Creating Ansible staging directory...")
+		if err := p.createDir(ui, comm, p.config.StagingDir); err != nil {
+			return fmt.Errorf("Error creating staging directory: %s", err)
+		}
 	}
 
 	ui.Message("Uploading main Playbook file...")
@@ -170,13 +190,29 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 		return fmt.Errorf("Error uploading main playbook: %s", err)
 	}
 
-	if len(p.config.InventoryFile) > 0 {
-		ui.Message("Uploading inventory file...")
-		src := p.config.InventoryFile
-		dst := filepath.Join(p.config.StagingDir, filepath.Base(src))
-		if err := p.uploadFile(ui, comm, dst, src); err != nil {
-			return fmt.Errorf("Error uploading inventory file: %s", err)
+	if len(p.config.InventoryFile) == 0 {
+		tf, err := ioutil.TempFile("", "packer-provisioner-ansible-local")
+		if err != nil {
+			return fmt.Errorf("Error preparing inventory file: %s", err)
 		}
+		defer os.Remove(tf.Name())
+		_, err = tf.Write([]byte("127.0.0.1"))
+		if err != nil {
+			tf.Close()
+			return fmt.Errorf("Error preparing inventory file: %s", err)
+		}
+		tf.Close()
+		p.config.InventoryFile = tf.Name()
+		defer func() {
+			p.config.InventoryFile = ""
+		}()
+	}
+
+	ui.Message("Uploading inventory file...")
+	src = p.config.InventoryFile
+	dst = filepath.ToSlash(filepath.Join(p.config.StagingDir, filepath.Base(src)))
+	if err := p.uploadFile(ui, comm, dst, src); err != nil {
+		return fmt.Errorf("Error uploading inventory file: %s", err)
 	}
 
 	if len(p.config.GroupVars) > 0 {
@@ -235,14 +271,7 @@ func (p *Provisioner) Cancel() {
 
 func (p *Provisioner) executeAnsible(ui packer.Ui, comm packer.Communicator) error {
 	playbook := filepath.ToSlash(filepath.Join(p.config.StagingDir, filepath.Base(p.config.PlaybookFile)))
-
-	// The inventory must be set to "127.0.0.1,".  The comma is important
-	// as its the only way to override the ansible inventory when dealing
-	// with a single host.
-	inventory := "\"127.0.0.1,\""
-	if len(p.config.InventoryFile) > 0 {
-		inventory = filepath.Join(p.config.StagingDir, filepath.Base(p.config.InventoryFile))
-	}
+	inventory := filepath.ToSlash(filepath.Join(p.config.StagingDir, filepath.Base(p.config.InventoryFile)))
 
 	extraArgs := ""
 	if len(p.config.ExtraArguments) > 0 {
@@ -302,7 +331,7 @@ func (p *Provisioner) uploadFile(ui packer.Ui, comm packer.Communicator, dst, sr
 	}
 	defer f.Close()
 
-	if err = comm.Upload(dst, f); err != nil {
+	if err = comm.Upload(dst, f, nil); err != nil {
 		return fmt.Errorf("Error uploading %s: %s", src, err)
 	}
 	return nil
diff --git a/provisioner/chef-client/provisioner.go b/provisioner/chef-client/provisioner.go
index 5c30bbe37..eff38dcb9 100644
--- a/provisioner/chef-client/provisioner.go
+++ b/provisioner/chef-client/provisioner.go
@@ -20,6 +20,7 @@ import (
 type Config struct {
 	common.PackerConfig `mapstructure:",squash"`
 
+	ChefEnvironment      string `mapstructure:"chef_environment"`
 	ConfigTemplate       string `mapstructure:"config_template"`
 	ExecuteCommand       string `mapstructure:"execute_command"`
 	InstallCommand       string `mapstructure:"install_command"`
@@ -47,6 +48,7 @@ type ConfigTemplate struct {
 	ServerUrl            string
 	ValidationKeyPath    string
 	ValidationClientName string
+	ChefEnvironment      string
 }
 
 type ExecuteTemplate struct {
@@ -71,6 +73,30 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 	}
 	p.config.tpl.UserVars = p.config.PackerUserVars
 
+	// Accumulate any errors
+	errs := common.CheckUnusedConfig(md)
+
+	templates := map[string]*string{
+		"chef_environment":       &p.config.ChefEnvironment,
+		"config_template":        &p.config.ConfigTemplate,
+		"node_name":              &p.config.NodeName,
+		"staging_dir":            &p.config.StagingDir,
+		"chef_server_url":        &p.config.ServerUrl,
+		"execute_command":        &p.config.ExecuteCommand,
+		"install_command":        &p.config.InstallCommand,
+		"validation_key_path":    &p.config.ValidationKeyPath,
+		"validation_client_name": &p.config.ValidationClientName,
+	}
+
+	for n, ptr := range templates {
+		var err error
+		*ptr, err = p.config.tpl.Process(*ptr, nil)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing %s: %s", n, err))
+		}
+	}
+
 	if p.config.ExecuteCommand == "" {
 		p.config.ExecuteCommand = "{{if .Sudo}}sudo {{end}}chef-client " +
 			"--no-color -c {{.ConfigPath}} -j {{.JsonPath}}"
@@ -90,25 +116,6 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 		p.config.StagingDir = "/tmp/packer-chef-client"
 	}
 
-	// Accumulate any errors
-	errs := common.CheckUnusedConfig(md)
-
-	templates := map[string]*string{
-		"config_template": &p.config.ConfigTemplate,
-		"node_name":       &p.config.NodeName,
-		"staging_dir":     &p.config.StagingDir,
-		"chef_server_url": &p.config.ServerUrl,
-	}
-
-	for n, ptr := range templates {
-		var err error
-		*ptr, err = p.config.tpl.Process(*ptr, nil)
-		if err != nil {
-			errs = packer.MultiErrorAppend(
-				errs, fmt.Errorf("Error processing %s: %s", n, err))
-		}
-	}
-
 	sliceTemplates := map[string][]string{
 		"run_list": p.config.RunList,
 	}
@@ -152,12 +159,24 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 			errs, fmt.Errorf("server_url must be set"))
 	}
 
-	// Process the user variables within the JSON and set the JSON.
-	// Do this early so that we can validate and show errors.
-	p.config.Json, err = p.processJsonUserVars()
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Error processing user variables in JSON: %s", err))
+	jsonValid := true
+	for k, v := range p.config.Json {
+		p.config.Json[k], err = p.deepJsonFix(k, v)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing JSON: %s", err))
+			jsonValid = false
+		}
+	}
+
+	if jsonValid {
+		// Process the user variables within the JSON and set the JSON.
+		// Do this early so that we can validate and show errors.
+		p.config.Json, err = p.processJsonUserVars()
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing user variables in JSON: %s", err))
+		}
 	}
 
 	if errs != nil && len(errs.Errors) > 0 {
@@ -190,7 +209,7 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 	}
 
 	configPath, err := p.createConfig(
-		ui, comm, nodeName, serverUrl, remoteValidationKeyPath, p.config.ValidationClientName)
+		ui, comm, nodeName, serverUrl, remoteValidationKeyPath, p.config.ValidationClientName, p.config.ChefEnvironment)
 	if err != nil {
 		return fmt.Errorf("Error creating Chef config file: %s", err)
 	}
@@ -208,7 +227,7 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 	}
 
 	if !p.config.SkipCleanClient {
-		if err2 := p.cleanClient(ui, comm, serverUrl); err2 != nil {
+		if err2 := p.cleanClient(ui, comm, nodeName); err2 != nil {
 			return fmt.Errorf("Error cleaning up chef client: %s", err2)
 		}
 	}
@@ -244,7 +263,7 @@ func (p *Provisioner) uploadDirectory(ui packer.Ui, comm packer.Communicator, ds
 	return comm.UploadDir(dst, src, nil)
 }
 
-func (p *Provisioner) createConfig(ui packer.Ui, comm packer.Communicator, nodeName string, serverUrl string, remoteKeyPath string, validationClientName string) (string, error) {
+func (p *Provisioner) createConfig(ui packer.Ui, comm packer.Communicator, nodeName string, serverUrl string, remoteKeyPath string, validationClientName string, chefEnvironment string) (string, error) {
 	ui.Message("Creating configuration file 'client.rb'")
 
 	// Read the template
@@ -269,13 +288,14 @@ func (p *Provisioner) createConfig(ui packer.Ui, comm packer.Communicator, nodeN
 		ServerUrl:            serverUrl,
 		ValidationKeyPath:    remoteKeyPath,
 		ValidationClientName: validationClientName,
+		ChefEnvironment:      chefEnvironment,
 	})
 	if err != nil {
 		return "", err
 	}
 
-	remotePath := filepath.Join(p.config.StagingDir, "client.rb")
-	if err := comm.Upload(remotePath, bytes.NewReader([]byte(configString))); err != nil {
+	remotePath := filepath.ToSlash(filepath.Join(p.config.StagingDir, "client.rb"))
+	if err := comm.Upload(remotePath, bytes.NewReader([]byte(configString)), nil); err != nil {
 		return "", err
 	}
 
@@ -303,8 +323,8 @@ func (p *Provisioner) createJson(ui packer.Ui, comm packer.Communicator) (string
 	}
 
 	// Upload the bytes
-	remotePath := filepath.Join(p.config.StagingDir, "first-boot.json")
-	if err := comm.Upload(remotePath, bytes.NewReader(jsonBytes)); err != nil {
+	remotePath := filepath.ToSlash(filepath.Join(p.config.StagingDir, "first-boot.json"))
+	if err := comm.Upload(remotePath, bytes.NewReader(jsonBytes), nil); err != nil {
 		return "", err
 	}
 
@@ -330,7 +350,7 @@ func (p *Provisioner) createDir(ui packer.Ui, comm packer.Communicator, dir stri
 
 func (p *Provisioner) cleanNode(ui packer.Ui, comm packer.Communicator, node string) error {
 	ui.Say("Cleaning up chef node...")
-	app := "knife node delete -y " + node
+	app := fmt.Sprintf("knife node delete %s -y", node)
 
 	cmd := exec.Command("sh", "-c", app)
 	out, err := cmd.Output()
@@ -346,7 +366,7 @@ func (p *Provisioner) cleanNode(ui packer.Ui, comm packer.Communicator, node str
 
 func (p *Provisioner) cleanClient(ui packer.Ui, comm packer.Communicator, node string) error {
 	ui.Say("Cleaning up chef client...")
-	app := "knife client delete -y " + node
+	app := fmt.Sprintf("knife client delete %s -y", node)
 
 	cmd := exec.Command("sh", "-c", app)
 	out, err := cmd.Output()
@@ -433,13 +453,54 @@ func (p *Provisioner) copyValidationKey(ui packer.Ui, comm packer.Communicator,
 	}
 	defer f.Close()
 
-	if err := comm.Upload(remotePath, f); err != nil {
+	if err := comm.Upload(remotePath, f, nil); err != nil {
 		return err
 	}
 
 	return nil
 }
 
+func (p *Provisioner) deepJsonFix(key string, current interface{}) (interface{}, error) {
+	if current == nil {
+		return nil, nil
+	}
+
+	switch c := current.(type) {
+	case []interface{}:
+		val := make([]interface{}, len(c))
+		for i, v := range c {
+			var err error
+			val[i], err = p.deepJsonFix(fmt.Sprintf("%s[%d]", key, i), v)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return val, nil
+	case []uint8:
+		return string(c), nil
+	case map[interface{}]interface{}:
+		val := make(map[string]interface{})
+		for k, v := range c {
+			ks, ok := k.(string)
+			if !ok {
+				return nil, fmt.Errorf("%s: key is not string", key)
+			}
+
+			var err error
+			val[ks], err = p.deepJsonFix(
+				fmt.Sprintf("%s.%s", key, ks), v)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return val, nil
+	default:
+		return current, nil
+	}
+}
+
 func (p *Provisioner) processJsonUserVars() (map[string]interface{}, error) {
 	jsonBytes, err := json.Marshal(p.config.Json)
 	if err != nil {
@@ -495,4 +556,7 @@ validation_key "{{.ValidationKeyPath}}"
 {{if ne .NodeName ""}}
 node_name "{{.NodeName}}"
 {{end}}
+{{if ne .ChefEnvironment ""}}
+environment "{{.ChefEnvironment}}"
+{{end}}
 `
diff --git a/provisioner/chef-client/provisioner_test.go b/provisioner/chef-client/provisioner_test.go
index b9d3b9c43..b6a5a9d2e 100644
--- a/provisioner/chef-client/provisioner_test.go
+++ b/provisioner/chef-client/provisioner_test.go
@@ -22,6 +22,22 @@ func TestProvisioner_Impl(t *testing.T) {
 	}
 }
 
+func TestProvisionerPrepare_chefEnvironment(t *testing.T) {
+	var p Provisioner
+
+	config := testConfig()
+	config["chef_environment"] = "some-env"
+
+	err := p.Prepare(config)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	if p.config.ChefEnvironment != "some-env" {
+		t.Fatalf("unexpected: %#v", p.config.ChefEnvironment)
+	}
+}
+
 func TestProvisionerPrepare_configTemplate(t *testing.T) {
 	var err error
 	var p Provisioner
diff --git a/provisioner/chef-solo/provisioner.go b/provisioner/chef-solo/provisioner.go
index 0d95a0ec5..3ee0e74c7 100644
--- a/provisioner/chef-solo/provisioner.go
+++ b/provisioner/chef-solo/provisioner.go
@@ -203,12 +203,24 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 		}
 	}
 
-	// Process the user variables within the JSON and set the JSON.
-	// Do this early so that we can validate and show errors.
-	p.config.Json, err = p.processJsonUserVars()
-	if err != nil {
-		errs = packer.MultiErrorAppend(
-			errs, fmt.Errorf("Error processing user variables in JSON: %s", err))
+	jsonValid := true
+	for k, v := range p.config.Json {
+		p.config.Json[k], err = p.deepJsonFix(k, v)
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing JSON: %s", err))
+			jsonValid = false
+		}
+	}
+
+	if jsonValid {
+		// Process the user variables within the JSON and set the JSON.
+		// Do this early so that we can validate and show errors.
+		p.config.Json, err = p.processJsonUserVars()
+		if err != nil {
+			errs = packer.MultiErrorAppend(
+				errs, fmt.Errorf("Error processing user variables in JSON: %s", err))
+		}
 	}
 
 	if errs != nil && len(errs.Errors) > 0 {
@@ -317,7 +329,7 @@ func (p *Provisioner) uploadFile(ui packer.Ui, comm packer.Communicator, dst str
 	}
 	defer f.Close()
 
-	return comm.Upload(dst, f)
+	return comm.Upload(dst, f, nil)
 }
 
 func (p *Provisioner) createConfig(ui packer.Ui, comm packer.Communicator, localCookbooks []string, rolesPath string, dataBagsPath string, encryptedDataBagSecretPath string, environmentsPath string, chefEnvironment string) (string, error) {
@@ -366,8 +378,8 @@ func (p *Provisioner) createConfig(ui packer.Ui, comm packer.Communicator, local
 		return "", err
 	}
 
-	remotePath := filepath.Join(p.config.StagingDir, "solo.rb")
-	if err := comm.Upload(remotePath, bytes.NewReader([]byte(configString))); err != nil {
+	remotePath := filepath.ToSlash(filepath.Join(p.config.StagingDir, "solo.rb"))
+	if err := comm.Upload(remotePath, bytes.NewReader([]byte(configString)), nil); err != nil {
 		return "", err
 	}
 
@@ -395,8 +407,8 @@ func (p *Provisioner) createJson(ui packer.Ui, comm packer.Communicator) (string
 	}
 
 	// Upload the bytes
-	remotePath := filepath.Join(p.config.StagingDir, "node.json")
-	if err := comm.Upload(remotePath, bytes.NewReader(jsonBytes)); err != nil {
+	remotePath := filepath.ToSlash(filepath.Join(p.config.StagingDir, "node.json"))
+	if err := comm.Upload(remotePath, bytes.NewReader(jsonBytes), nil); err != nil {
 		return "", err
 	}
 
@@ -470,6 +482,47 @@ func (p *Provisioner) installChef(ui packer.Ui, comm packer.Communicator) error
 	return nil
 }
 
+func (p *Provisioner) deepJsonFix(key string, current interface{}) (interface{}, error) {
+	if current == nil {
+		return nil, nil
+	}
+
+	switch c := current.(type) {
+	case []interface{}:
+		val := make([]interface{}, len(c))
+		for i, v := range c {
+			var err error
+			val[i], err = p.deepJsonFix(fmt.Sprintf("%s[%d]", key, i), v)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return val, nil
+	case []uint8:
+		return string(c), nil
+	case map[interface{}]interface{}:
+		val := make(map[string]interface{})
+		for k, v := range c {
+			ks, ok := k.(string)
+			if !ok {
+				return nil, fmt.Errorf("%s: key is not string", key)
+			}
+
+			var err error
+			val[ks], err = p.deepJsonFix(
+				fmt.Sprintf("%s.%s", key, ks), v)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		return val, nil
+	default:
+		return current, nil
+	}
+}
+
 func (p *Provisioner) processJsonUserVars() (map[string]interface{}, error) {
 	jsonBytes, err := json.Marshal(p.config.Json)
 	if err != nil {
diff --git a/provisioner/chef-solo/provisioner_test.go b/provisioner/chef-solo/provisioner_test.go
index f7094103e..67fc1009a 100644
--- a/provisioner/chef-solo/provisioner_test.go
+++ b/provisioner/chef-solo/provisioner_test.go
@@ -262,3 +262,42 @@ func TestProvisionerPrepare_json(t *testing.T) {
 		t.Fatalf("bad: %#v", p.config.Json)
 	}
 }
+
+func TestProvisionerPrepare_jsonNested(t *testing.T) {
+	config := testConfig()
+	config["json"] = map[string]interface{}{
+		"foo": map[interface{}]interface{}{
+			"bar": []uint8("baz"),
+		},
+
+		"bar": []interface{}{
+			"foo",
+
+			map[interface{}]interface{}{
+				"bar": "baz",
+			},
+		},
+
+		"bFalse": false,
+		"bTrue":  true,
+		"bNil":   nil,
+		"bStr":   []uint8("bar"),
+
+		"bInt":   1,
+		"bFloat": 4.5,
+	}
+
+	var p Provisioner
+	err := p.Prepare(config)
+	if err != nil {
+		t.Fatalf("err: %s", err)
+	}
+
+	fooMap := p.config.Json["foo"].(map[string]interface{})
+	if fooMap["bar"] != "baz" {
+		t.Fatalf("nope: %#v", fooMap["bar"])
+	}
+	if p.config.Json["bStr"] != "bar" {
+		t.Fatalf("nope: %#v", fooMap["bar"])
+	}
+}
diff --git a/provisioner/file/provisioner.go b/provisioner/file/provisioner.go
index c20cbd0f2..1cb69acd4 100644
--- a/provisioner/file/provisioner.go
+++ b/provisioner/file/provisioner.go
@@ -89,7 +89,12 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 	}
 	defer f.Close()
 
-	err = comm.Upload(p.config.Destination, f)
+	fi, err := f.Stat()
+	if err != nil {
+		return err
+	}
+
+	err = comm.Upload(p.config.Destination, f, &fi)
 	if err != nil {
 		ui.Error(fmt.Sprintf("Upload failed: %s", err))
 	}
diff --git a/provisioner/puppet-masterless/provisioner.go b/provisioner/puppet-masterless/provisioner.go
index a290948fd..81ab34afa 100644
--- a/provisioner/puppet-masterless/provisioner.go
+++ b/provisioner/puppet-masterless/provisioner.go
@@ -301,7 +301,7 @@ func (p *Provisioner) uploadHieraConfig(ui packer.Ui, comm packer.Communicator)
 	defer f.Close()
 
 	path := fmt.Sprintf("%s/hiera.yaml", p.config.StagingDir)
-	if err := comm.Upload(path, f); err != nil {
+	if err := comm.Upload(path, f, nil); err != nil {
 		return "", err
 	}
 
@@ -325,7 +325,7 @@ func (p *Provisioner) uploadManifests(ui packer.Ui, comm packer.Communicator) (s
 
 	manifestFilename := filepath.Base(p.config.ManifestFile)
 	remoteManifestFile := fmt.Sprintf("%s/%s", remoteManifestsPath, manifestFilename)
-	if err := comm.Upload(remoteManifestFile, f); err != nil {
+	if err := comm.Upload(remoteManifestFile, f, nil); err != nil {
 		return "", err
 	}
 
diff --git a/provisioner/salt-masterless/provisioner.go b/provisioner/salt-masterless/provisioner.go
index d13ca1f84..5223485cb 100644
--- a/provisioner/salt-masterless/provisioner.go
+++ b/provisioner/salt-masterless/provisioner.go
@@ -8,6 +8,7 @@ import (
 	"github.com/mitchellh/packer/common"
 	"github.com/mitchellh/packer/packer"
 	"os"
+	"path/filepath"
 )
 
 const DefaultTempConfigDir = "/tmp/salt"
@@ -74,7 +75,11 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 		}
 	}
 
-	if p.config.LocalStateTree != "" {
+	// require a salt state tree
+	if p.config.LocalStateTree == "" {
+		errs = packer.MultiErrorAppend(errs,
+			errors.New("local_state_tree must be supplied"))
+	} else {
 		if _, err := os.Stat(p.config.LocalStateTree); err != nil {
 			errs = packer.MultiErrorAppend(errs,
 				errors.New("local_state_tree must exist and be accessible"))
@@ -104,11 +109,12 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 
 func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 	var err error
+	var src, dst string
 
 	ui.Say("Provisioning with Salt...")
 	if !p.config.SkipBootstrap {
 		cmd := &packer.RemoteCmd{
-			Command: fmt.Sprintf("wget -O - http://bootstrap.saltstack.org | sudo sh -s %s", p.config.BootstrapArgs),
+			Command: fmt.Sprintf("wget -O - https://bootstrap.saltstack.com | sudo sh -s %s", p.config.BootstrapArgs),
 		}
 		ui.Message(fmt.Sprintf("Installing Salt with command %s", cmd))
 		if err = cmd.StartWithUi(comm, ui); err != nil {
@@ -117,68 +123,58 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 	}
 
 	ui.Message(fmt.Sprintf("Creating remote directory: %s", p.config.TempConfigDir))
-	cmd := &packer.RemoteCmd{Command: fmt.Sprintf("mkdir -p %s", p.config.TempConfigDir)}
-	if err = cmd.StartWithUi(comm, ui); err != nil || cmd.ExitStatus != 0 {
-		if err == nil {
-			err = fmt.Errorf("Bad exit status: %d", cmd.ExitStatus)
-		}
-
+	if err := p.createDir(ui, comm, p.config.TempConfigDir); err != nil {
 		return fmt.Errorf("Error creating remote salt state directory: %s", err)
 	}
 
 	if p.config.MinionConfig != "" {
 		ui.Message(fmt.Sprintf("Uploading minion config: %s", p.config.MinionConfig))
-		if err = uploadMinionConfig(comm, fmt.Sprintf("%s/minion", p.config.TempConfigDir), p.config.MinionConfig); err != nil {
+		src = p.config.MinionConfig
+		dst = filepath.ToSlash(filepath.Join(p.config.TempConfigDir, "minion"))
+		if err = p.uploadFile(ui, comm, dst, src); err != nil {
 			return fmt.Errorf("Error uploading local minion config file to remote: %s", err)
 		}
 
-		ui.Message(fmt.Sprintf("Moving %s/minion to /etc/salt/minion", p.config.TempConfigDir))
-		cmd = &packer.RemoteCmd{Command: fmt.Sprintf("sudo mv %s/minion /etc/salt/minion", p.config.TempConfigDir)}
-		if err = cmd.StartWithUi(comm, ui); err != nil || cmd.ExitStatus != 0 {
-			if err == nil {
-				err = fmt.Errorf("Bad exit status: %d", cmd.ExitStatus)
-			}
-
+		// move minion config into /etc/salt
+		src = filepath.ToSlash(filepath.Join(p.config.TempConfigDir, "minion"))
+		dst = "/etc/salt/minion"
+		if err = p.moveFile(ui, comm, dst, src); err != nil {
 			return fmt.Errorf("Unable to move %s/minion to /etc/salt/minion: %d", p.config.TempConfigDir, err)
 		}
 	}
 
 	ui.Message(fmt.Sprintf("Uploading local state tree: %s", p.config.LocalStateTree))
-	if err = comm.UploadDir(fmt.Sprintf("%s/states", p.config.TempConfigDir),
-		p.config.LocalStateTree, []string{".git"}); err != nil {
+	src = p.config.LocalStateTree
+	dst = filepath.ToSlash(filepath.Join(p.config.TempConfigDir, "states"))
+	if err = p.uploadDir(ui, comm, dst, src, []string{".git"}); err != nil {
 		return fmt.Errorf("Error uploading local state tree to remote: %s", err)
 	}
 
-	ui.Message(fmt.Sprintf("Moving %s/states to /srv/salt", p.config.TempConfigDir))
-	cmd = &packer.RemoteCmd{Command: fmt.Sprintf("sudo mv %s/states /srv/salt", p.config.TempConfigDir)}
-	if err = cmd.StartWithUi(comm, ui); err != nil || cmd.ExitStatus != 0 {
-		if err == nil {
-			err = fmt.Errorf("Bad exit status: %d", cmd.ExitStatus)
-		}
-
+	// move state tree into /srv/salt
+	src = filepath.ToSlash(filepath.Join(p.config.TempConfigDir, "states"))
+	dst = "/srv/salt"
+	if err = p.moveFile(ui, comm, dst, src); err != nil {
 		return fmt.Errorf("Unable to move %s/states to /srv/salt: %d", p.config.TempConfigDir, err)
 	}
 
 	if p.config.LocalPillarRoots != "" {
 		ui.Message(fmt.Sprintf("Uploading local pillar roots: %s", p.config.LocalPillarRoots))
-		if err = comm.UploadDir(fmt.Sprintf("%s/pillar", p.config.TempConfigDir),
-			p.config.LocalPillarRoots, []string{".git"}); err != nil {
+		src = p.config.LocalPillarRoots
+		dst = filepath.ToSlash(filepath.Join(p.config.TempConfigDir, "pillar"))
+		if err = p.uploadDir(ui, comm, dst, src, []string{".git"}); err != nil {
 			return fmt.Errorf("Error uploading local pillar roots to remote: %s", err)
 		}
 
-		ui.Message(fmt.Sprintf("Moving %s/pillar to /srv/pillar", p.config.TempConfigDir))
-		cmd = &packer.RemoteCmd{Command: fmt.Sprintf("sudo mv %s/pillar /srv/pillar", p.config.TempConfigDir)}
-		if err = cmd.StartWithUi(comm, ui); err != nil || cmd.ExitStatus != 0 {
-			if err == nil {
-				err = fmt.Errorf("Bad exit status: %d", cmd.ExitStatus)
-			}
-
+		// move pillar tree into /srv/pillar
+		src = filepath.ToSlash(filepath.Join(p.config.TempConfigDir, "pillar"))
+		dst = "/srv/pillar"
+		if err = p.moveFile(ui, comm, dst, src); err != nil {
 			return fmt.Errorf("Unable to move %s/pillar to /srv/pillar: %d", p.config.TempConfigDir, err)
 		}
 	}
 
 	ui.Message("Running highstate")
-	cmd = &packer.RemoteCmd{Command: "sudo salt-call --local state.highstate -l info"}
+	cmd := &packer.RemoteCmd{Command: "sudo salt-call --local state.highstate -l info"}
 	if err = cmd.StartWithUi(comm, ui); err != nil || cmd.ExitStatus != 0 {
 		if err == nil {
 			err = fmt.Errorf("Bad exit status: %d", cmd.ExitStatus)
@@ -196,16 +192,55 @@ func (p *Provisioner) Cancel() {
 	os.Exit(0)
 }
 
-func uploadMinionConfig(comm packer.Communicator, dst string, src string) error {
+func (p *Provisioner) uploadFile(ui packer.Ui, comm packer.Communicator, dst, src string) error {
 	f, err := os.Open(src)
 	if err != nil {
-		return fmt.Errorf("Error opening minion config: %s", err)
+		return fmt.Errorf("Error opening: %s", err)
 	}
 	defer f.Close()
 
-	if err = comm.Upload(dst, f); err != nil {
-		return fmt.Errorf("Error uploading minion config: %s", err)
+	if err = comm.Upload(dst, f, nil); err != nil {
+		return fmt.Errorf("Error uploading %s: %s", src, err)
 	}
-
 	return nil
 }
+
+func (p *Provisioner) moveFile(ui packer.Ui, comm packer.Communicator, dst, src string) error {
+	ui.Message(fmt.Sprintf("Moving %s to %s", src, dst))
+	cmd := &packer.RemoteCmd{Command: fmt.Sprintf("sudo mv %s %s", src, dst)}
+	if err := cmd.StartWithUi(comm, ui); err != nil || cmd.ExitStatus != 0 {
+		if err == nil {
+			err = fmt.Errorf("Bad exit status: %d", cmd.ExitStatus)
+		}
+
+		return fmt.Errorf("Unable to move %s/minion to /etc/salt/minion: %d", p.config.TempConfigDir, err)
+	}
+	return nil
+}
+
+func (p *Provisioner) createDir(ui packer.Ui, comm packer.Communicator, dir string) error {
+	ui.Message(fmt.Sprintf("Creating directory: %s", dir))
+	cmd := &packer.RemoteCmd{
+		Command: fmt.Sprintf("mkdir -p '%s'", dir),
+	}
+	if err := cmd.StartWithUi(comm, ui); err != nil {
+		return err
+	}
+	if cmd.ExitStatus != 0 {
+		return fmt.Errorf("Non-zero exit status.")
+	}
+	return nil
+}
+
+func (p *Provisioner) uploadDir(ui packer.Ui, comm packer.Communicator, dst, src string, ignore []string) error {
+	if err := p.createDir(ui, comm, dst); err != nil {
+		return err
+	}
+
+	// Make sure there is a trailing "/" so that the directory isn't
+	// created on the other side.
+	if src[len(src)-1] != '/' {
+		src = src + "/"
+	}
+	return comm.UploadDir(dst, src, ignore)
+}
diff --git a/provisioner/shell/provisioner.go b/provisioner/shell/provisioner.go
index a5ec2e2bb..ec22acf63 100644
--- a/provisioner/shell/provisioner.go
+++ b/provisioner/shell/provisioner.go
@@ -170,11 +170,14 @@ func (p *Provisioner) Prepare(raws ...interface{}) error {
 	}
 
 	// Do a check for bad environment variables, such as '=foo', 'foobar'
-	for _, kv := range p.config.Vars {
+	for idx, kv := range p.config.Vars {
 		vs := strings.SplitN(kv, "=", 2)
 		if len(vs) != 2 || vs[0] == "" {
 			errs = packer.MultiErrorAppend(errs,
 				fmt.Errorf("Environment variable not in format 'key=value': %s", kv))
+		} else {
+			// Single quote env var values
+			p.config.Vars[idx] = fmt.Sprintf("%s='%s'", vs[0], vs[1])
 		}
 	}
 
@@ -227,8 +230,8 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 
 	// Build our variables up by adding in the build name and builder type
 	envVars := make([]string, len(p.config.Vars)+2)
-	envVars[0] = "PACKER_BUILD_NAME=" + p.config.PackerBuildName
-	envVars[1] = "PACKER_BUILDER_TYPE=" + p.config.PackerBuilderType
+	envVars[0] = fmt.Sprintf("PACKER_BUILD_NAME='%s'", p.config.PackerBuildName)
+	envVars[1] = fmt.Sprintf("PACKER_BUILDER_TYPE='%s'", p.config.PackerBuilderType)
 	copy(envVars[2:], p.config.Vars)
 
 	for _, path := range scripts {
@@ -269,7 +272,7 @@ func (p *Provisioner) Provision(ui packer.Ui, comm packer.Communicator) error {
 				r = &UnixReader{Reader: r}
 			}
 
-			if err := comm.Upload(p.config.RemotePath, r); err != nil {
+			if err := comm.Upload(p.config.RemotePath, r, nil); err != nil {
 				return fmt.Errorf("Error uploading script: %s", err)
 			}
 
diff --git a/provisioner/shell/provisioner_test.go b/provisioner/shell/provisioner_test.go
index ab5308bd2..4fd5a5cad 100644
--- a/provisioner/shell/provisioner_test.go
+++ b/provisioner/shell/provisioner_test.go
@@ -199,3 +199,21 @@ func TestProvisionerPrepare_EnvironmentVars(t *testing.T) {
 		t.Fatalf("should not have error: %s", err)
 	}
 }
+
+func TestProvisionerQuote_EnvironmentVars(t *testing.T) {
+	config := testConfig()
+
+	config["environment_vars"] = []string{"keyone=valueone", "keytwo=value\ntwo"}
+	p := new(Provisioner)
+	p.Prepare(config)
+
+	expectedValue := "keyone='valueone'"
+	if p.config.Vars[0] != expectedValue {
+		t.Fatalf("%s should be equal to %s", p.config.Vars[0], expectedValue)
+	}
+
+	expectedValue = "keytwo='value\ntwo'"
+	if p.config.Vars[1] != expectedValue {
+		t.Fatalf("%s should be equal to %s", p.config.Vars[1], expectedValue)
+	}
+}
diff --git a/scripts/build.sh b/scripts/build.sh
new file mode 100755
index 000000000..c265b88c2
--- /dev/null
+++ b/scripts/build.sh
@@ -0,0 +1,79 @@
+#!/bin/bash
+#
+# This script builds the application from source for multiple platforms.
+set -e
+
+# Get the parent directory of where this script is.
+SOURCE="${BASH_SOURCE[0]}"
+while [ -h "$SOURCE" ] ; do SOURCE="$(readlink "$SOURCE")"; done
+DIR="$( cd -P "$( dirname "$SOURCE" )/.." && pwd )"
+
+# Change into that directory
+cd $DIR
+
+# Get the git commit
+GIT_COMMIT=$(git rev-parse HEAD)
+GIT_DIRTY=$(test -n "`git status --porcelain`" && echo "+CHANGES" || true)
+
+# If its dev mode, only build for ourself
+if [ "${TF_DEV}x" != "x" ]; then
+    XC_OS=${XC_OS:-$(go env GOOS)}
+    XC_ARCH=${XC_ARCH:-$(go env GOARCH)}
+fi
+
+# Determine the arch/os combos we're building for
+XC_ARCH=${XC_ARCH:-"386 amd64 arm"}
+XC_OS=${XC_OS:-linux darwin windows freebsd openbsd}
+
+# Install dependencies
+echo "==> Getting dependencies..."
+go get ./...
+
+# Delete the old dir
+echo "==> Removing old directory..."
+rm -f bin/*
+rm -rf pkg/*
+mkdir -p bin/
+
+# Build!
+echo "==> Building..."
+set +e
+gox \
+    -os="${XC_OS}" \
+    -arch="${XC_ARCH}" \
+    -ldflags "-X main.GitCommit ${GIT_COMMIT}${GIT_DIRTY}" \
+    -output "pkg/{{.OS}}_{{.Arch}}/packer-{{.Dir}}" \
+    ./...
+set -e
+
+# Make sure "packer-packer" is renamed properly
+for PLATFORM in $(find ./pkg -mindepth 1 -maxdepth 1 -type d); do
+    set +e
+    mv ${PLATFORM}/packer-packer.exe ${PLATFORM}/packer.exe 2>/dev/null
+    mv ${PLATFORM}/packer-packer ${PLATFORM}/packer 2>/dev/null
+    set -e
+done
+
+# Move all the compiled things to the $GOPATH/bin
+GOPATH=${GOPATH:-$(go env GOPATH)}
+case $(uname) in
+    CYGWIN*)
+        GOPATH="$(cygpath $GOPATH)"
+        ;;
+esac
+OLDIFS=$IFS
+IFS=: MAIN_GOPATH=($GOPATH)
+IFS=$OLDIFS
+
+# Copy our OS/Arch to the bin/ directory
+echo "==> Copying binaries for this platform..."
+DEV_PLATFORM="./pkg/$(go env GOOS)_$(go env GOARCH)"
+for F in $(find ${DEV_PLATFORM} -mindepth 1 -maxdepth 1 -type f); do
+    cp ${F} bin/
+    cp ${F} ${MAIN_GOPATH}/bin/
+done
+
+# Done!
+echo
+echo "==> Results:"
+ls -hl bin/
diff --git a/scripts/compile.sh b/scripts/compile.sh
deleted file mode 100755
index d2af8cdd1..000000000
--- a/scripts/compile.sh
+++ /dev/null
@@ -1,52 +0,0 @@
-#!/bin/bash
-#
-# This script compiles Packer for various platforms (specified by the
-# PACKER_OS and PACKER_ARCH environmental variables).
-set -e
-
-NO_COLOR="\x1b[0m"
-OK_COLOR="\x1b[32;01m"
-ERROR_COLOR="\x1b[31;01m"
-WARN_COLOR="\x1b[33;01m"
-
-# Get the parent directory of where this script is.
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ] ; do SOURCE="$(readlink "$SOURCE")"; done
-DIR="$( cd -P "$( dirname "$SOURCE" )/.." && pwd )"
-
-# Change into that directory
-cd $DIR
-
-# Get the git commit
-GIT_COMMIT=$(git rev-parse HEAD)
-GIT_DIRTY=$(test -n "`git status --porcelain`" && echo "+CHANGES" || true)
-
-# Determine the arch/os combos we're building for
-XC_ARCH=${XC_ARCH:-"386 amd64 arm"}
-XC_OS=${XC_OS:-linux darwin windows freebsd openbsd}
-
-# Make sure that if we're killed, we kill all our subprocseses
-trap "kill 0" SIGINT SIGTERM EXIT
-
-echo -e "${OK_COLOR}==> Installing dependencies to speed up builds...${NO_COLOR}"
-go get ./...
-
-echo -e "${OK_COLOR}==> Beginning compile...${NO_COLOR}"
-rm -rf pkg/
-gox \
-    -os="${XC_OS}" \
-    -arch="${XC_ARCH}" \
-    -ldflags "-X github.com/mitchellh/packer/packer.GitCommit ${GIT_COMMIT}${GIT_DIRTY}" \
-    -output "pkg/{{.OS}}_{{.Arch}}/packer-{{.Dir}}" \
-    ./...
-
-# Make sure "packer-packer" is renamed properly
-for PLATFORM in $(find ./pkg -mindepth 1 -maxdepth 1 -type d); do
-    set +e
-    mv ${PLATFORM}/packer-packer ${PLATFORM}/packer 2>/dev/null
-    mv ${PLATFORM}/packer-packer.exe ${PLATFORM}/packer.exe 2>/dev/null
-    set -e
-done
-
-# Reset signal trapping to avoid "Terminated: 15" at the end
-trap - SIGINT SIGTERM EXIT
diff --git a/scripts/devcompile.sh b/scripts/devcompile.sh
deleted file mode 100755
index 13a4a7740..000000000
--- a/scripts/devcompile.sh
+++ /dev/null
@@ -1,63 +0,0 @@
-#!/bin/bash
-#
-# This script only builds the application from source.
-set -e
-
-NO_COLOR="\x1b[0m"
-OK_COLOR="\x1b[32;01m"
-ERROR_COLOR="\x1b[31;01m"
-WARN_COLOR="\x1b[33;01m"
-
-# http://stackoverflow.com/questions/4023830/bash-how-compare-two-strings-in-version-format
-verify_go () {
-    if [[ $1 == $2 ]]; then
-        return 0
-    fi
-
-    local IFS=.
-    local i ver1=($1) ver2=($2)
-
-    for ((i=${#ver1[@]}; i<${#ver2[@]}; i++)); do
-        ver1[i]=0
-    done
-
-    for ((i=0; i<${#ver1[@]}; i++)); do
-        if [[ -z ${ver2[i]} ]]; then
-            ver2[i]=0
-        fi
-        if ((10#${ver1[i]} > 10#${ver2[i]})); then
-            echo -e "${ERROR_COLOR}==> Required Go version $1 not installed. Found $2 instead"
-            exit 1
-        fi
-    done
-}
-
-GO_MINIMUM_VERSION=1.2
-GO_INSTALLED_VERSION=$(go version | cut -d ' ' -f 3)
-GO_INSTALLED_VERSION=${GO_INSTALLED_VERSION#"go"}
-
-echo -e "${OK_COLOR}==> Verifying Go"
-verify_go $GO_MINIMUM_VERSION $GO_INSTALLED_VERSION
-
-# Get the parent directory of where this script is.
-SOURCE="${BASH_SOURCE[0]}"
-while [ -h "$SOURCE" ] ; do SOURCE="$(readlink "$SOURCE")"; done
-DIR="$( cd -P "$( dirname "$SOURCE" )/.." && pwd )"
-
-# Change into that directory
-cd $DIR
-
-# Compile the thing
-export XC_ARCH=$(go env GOARCH)
-export XC_OS=$(go env GOOS)
-./scripts/compile.sh
-
-# Move all the compiled things to the PATH
-case $(uname) in
-    CYGWIN*)
-        GOPATH="$(cygpath $GOPATH)"
-        ;;
-esac
-IFS=: MAIN_GOPATH=( $GOPATH )
-cp pkg/${XC_OS}_${XC_ARCH}/* ${MAIN_GOPATH}/bin
-cp pkg/${XC_OS}_${XC_ARCH}/* ./bin
diff --git a/scripts/dist.sh b/scripts/dist.sh
index 0768ff0ae..9533ef285 100755
--- a/scripts/dist.sh
+++ b/scripts/dist.sh
@@ -9,59 +9,49 @@ DIR="$( cd -P "$( dirname "$SOURCE" )/.." && pwd )"
 # Change into that dir because we expect that
 cd $DIR
 
-# Determine the version that we're building based on the contents
-# of packer/version.go.
-VERSION=$(grep "const Version " packer/version.go | sed -E 's/.*"(.+)"$/\1/')
-VERSIONDIR="${VERSION}"
-PREVERSION=$(grep "const VersionPrerelease " packer/version.go | sed -E 's/.*"(.*)"$/\1/')
-if [ ! -z $PREVERSION ]; then
-    PREVERSION="${PREVERSION}.$(date -u +%s)"
-    VERSIONDIR="${VERSIONDIR}-${PREVERSION}"
+# Get the version from the command line
+VERSION=$1
+if [ -z $VERSION ]; then
+    echo "Please specify a version."
+    exit 1
 fi
 
-# This function waits for all background tasks to complete
-waitAll() {
-    RESULT=0
-    for job in `jobs -p`; do
-        wait $job
-        if [ $? -ne 0 ]; then
-            RESULT=1
-        fi
-    done
+# Make sure we have a bintray API key
+if [ -z $BINTRAY_API_KEY ]; then
+    echo "Please set your bintray API key in the BINTRAY_API_KEY env var."
+    exit 1
+fi
 
-    if [ $RESULT -ne 0 ]; then
-        exit $RESULT
-    fi
-}
-
-# Compile the main project
-./scripts/compile.sh
-
-# Make sure that if we're killed, we kill all our subprocseses
-trap "kill 0" SIGINT SIGTERM EXIT
-
-# Zip all the packages
+# Zip and copy to the dist dir
+echo "==> Packaging..."
+rm -rf ./pkg/dist
 mkdir -p ./pkg/dist
 for PLATFORM in $(find ./pkg -mindepth 1 -maxdepth 1 -type d); do
-    PLATFORM_NAME=$(basename ${PLATFORM})
-    ARCHIVE_NAME="${VERSIONDIR}_${PLATFORM_NAME}"
+    OSARCH=$(basename ${PLATFORM})
 
-    if [ $PLATFORM_NAME = "dist" ]; then
+    if [ $OSARCH = "dist" ]; then
         continue
     fi
 
-    (
-    pushd ${PLATFORM}
-    zip ${DIR}/pkg/dist/${ARCHIVE_NAME}.zip ./*
-    popd
-    ) &
+    echo "--> ${OSARCH}"
+    pushd $PLATFORM >/dev/null 2>&1
+    zip ../dist/packer_${VERSION}_${OSARCH}.zip ./*
+    popd >/dev/null 2>&1
 done
 
-waitAll
-
 # Make the checksums
-pushd ./pkg/dist
-shasum -a256 * > ./${VERSIONDIR}_SHA256SUMS
-popd
+echo "==> Checksumming..."
+pushd ./pkg/dist >/dev/null 2>&1
+shasum -a256 * > ./packer_${VERSION}_SHA256SUMS
+popd >/dev/null 2>&1
 
-exit 0
+echo "==> Uploading..."
+for ARCHIVE in ./pkg/dist/*; do
+    ARCHIVE_NAME=$(basename ${ARCHIVE})
+
+    echo Uploading: $ARCHIVE_NAME
+    curl \
+        -T ${ARCHIVE} \
+        -umitchellh:${BINTRAY_API_KEY} \
+        "https://api.bintray.com/content/mitchellh/packer/packer/${VERSION}/${ARCHIVE_NAME}"
+done
diff --git a/test/README.md b/test/README.md
index 79d1d7909..e29fe9b24 100644
--- a/test/README.md
+++ b/test/README.md
@@ -41,8 +41,7 @@ Set the following self-explanatory environmental variables:
 Set the following environmental variables:
 
 * `GC_BUCKET_NAME`
-* `GC_CLIENT_SECRETS_FILE`
-* `GC_PRIVATE_KEY_FILE`
+* `GC_ACCOUNT_FILE`
 * `GC_PROJECT_ID`
 
 ### Running
diff --git a/test/builder_googlecompute.bats b/test/builder_googlecompute.bats
index 2c1ad8ab0..d7062a9a8 100755
--- a/test/builder_googlecompute.bats
+++ b/test/builder_googlecompute.bats
@@ -8,8 +8,7 @@ fixtures builder-googlecompute
 
 # Required parameters
 : ${GC_BUCKET_NAME:?}
-: ${GC_CLIENT_SECRETS_FILE:?}
-: ${GC_PRIVATE_KEY_FILE:?}
+: ${GC_ACCOUNT_FILE:?}
 : ${GC_PROJECT_ID:?}
 command -v gcutil >/dev/null 2>&1 || {
     echo "'gcutil' must be installed" >&2
@@ -17,8 +16,7 @@ command -v gcutil >/dev/null 2>&1 || {
 }
 
 USER_VARS="-var bucket_name=${GC_BUCKET_NAME}"
-USER_VARS="${USER_VARS} -var client_secrets_file=${GC_CLIENT_SECRETS_FILE}"
-USER_VARS="${USER_VARS} -var private_key_file=${GC_PRIVATE_KEY_FILE}"
+USER_VARS="${USER_VARS} -var account_file=${GC_ACCOUNT_FILE}"
 USER_VARS="${USER_VARS} -var project_id=${GC_PROJECT_ID}"
 
 # This tests if GCE has an image that contains the given parameter.
@@ -30,7 +28,7 @@ gc_has_image() {
 teardown() {
     gcutil --format=names --project=${GC_PROJECT_ID} listimages \
         | grep packerbats \
-        | xargs -n1 gcutil --project=${GC_PROJECT_ID} --force deleteimage
+        | xargs -n1 gcutil --project=${GC_PROJECT_ID} deleteimage --force
 }
 
 @test "googlecompute: build minimal.json" {
diff --git a/test/fixtures/builder-googlecompute/minimal.json b/test/fixtures/builder-googlecompute/minimal.json
index f2a206833..218e98b9a 100644
--- a/test/fixtures/builder-googlecompute/minimal.json
+++ b/test/fixtures/builder-googlecompute/minimal.json
@@ -1,20 +1,18 @@
 {
     "variables": {
         "bucket_name": null,
-        "client_secrets_file": null,
-        "private_key_file": null,
+        "account_file": null,
         "project_id": null
     },
 
     "builders": [{
         "type": "googlecompute",
         "bucket_name": "{{user `bucket_name`}}",
-        "client_secrets_file": "{{user `client_secrets_file`}}",
-        "private_key_file": "{{user `private_key_file`}}",
+        "account_file": "{{user `account_file`}}",
         "project_id": "{{user `project_id`}}",
 
         "image_name": "packerbats-minimal-{{timestamp}}",
-        "source_image": "debian-7-wheezy-v20131120",
+        "source_image": "debian-7-wheezy-v20141108",
         "zone": "us-central1-a"
     }]
 }
diff --git a/version.go b/version.go
new file mode 100644
index 000000000..dbfc8da12
--- /dev/null
+++ b/version.go
@@ -0,0 +1,12 @@
+package main
+
+// The git commit that was compiled. This will be filled in by the compiler.
+var GitCommit string
+
+// The main version number that is being run at the moment.
+const Version = "0.8.0"
+
+// A pre-release marker for the version. If this is "" (empty string)
+// then it means that it is a final release. Otherwise, this is a pre-release
+// such as "dev" (in development), "beta", "rc1", etc.
+const VersionPrerelease = "dev"
diff --git a/website/Gemfile b/website/Gemfile
index 5aebf0d94..8fc173cfd 100644
--- a/website/Gemfile
+++ b/website/Gemfile
@@ -1,12 +1,5 @@
 source 'https://rubygems.org'
 
-gem "middleman", "~> 3.1.5"
-gem "middleman-minify-html", "~> 3.1.1"
-gem "rack-contrib", "~> 1.1.0"
-gem "redcarpet", "~> 3.0.0"
-gem "therubyracer", "~> 0.12.0"
-gem "thin", "~> 1.5.0"
+ruby "2.0.0"
 
-group :development do
-  gem "highline", "~> 1.6.15"
-end
+gem 'middleman-hashicorp', github: 'hashicorp/middleman-hashicorp'
diff --git a/website/Gemfile.lock b/website/Gemfile.lock
index cc154491d..170034efc 100644
--- a/website/Gemfile.lock
+++ b/website/Gemfile.lock
@@ -1,109 +1,173 @@
+GIT
+  remote: git://github.com/hashicorp/middleman-hashicorp.git
+  revision: b82c2c2fdc244cd0bd529ff27cfab24e43f07708
+  specs:
+    middleman-hashicorp (0.1.0)
+      bootstrap-sass (~> 3.2)
+      builder (~> 3.2)
+      less (~> 2.6)
+      middleman (~> 3.3)
+      middleman-livereload (~> 3.3)
+      middleman-minify-html (~> 3.4)
+      middleman-syntax (~> 2.0)
+      rack-contrib (~> 1.1)
+      rack-rewrite (~> 1.5)
+      rack-ssl-enforcer (~> 0.2)
+      redcarpet (~> 3.1)
+      therubyracer (~> 0.12)
+      thin (~> 1.6)
+
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (3.2.15)
-      i18n (~> 0.6, >= 0.6.4)
-      multi_json (~> 1.0)
-    chunky_png (1.2.9)
-    coffee-script (2.2.0)
+    activesupport (4.1.6)
+      i18n (~> 0.6, >= 0.6.9)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.1)
+      tzinfo (~> 1.1)
+    bootstrap-sass (3.2.0.2)
+      sass (~> 3.2)
+    builder (3.2.2)
+    celluloid (0.16.0)
+      timers (~> 4.0.0)
+    chunky_png (1.3.3)
+    coffee-script (2.3.0)
       coffee-script-source
       execjs
-    coffee-script-source (1.6.3)
-    compass (0.12.2)
+    coffee-script-source (1.8.0)
+    commonjs (0.2.7)
+    compass (1.0.1)
       chunky_png (~> 1.2)
-      fssm (>= 0.2.7)
-      sass (~> 3.1)
-    daemons (1.1.9)
-    eventmachine (1.0.3)
-    execjs (1.4.0)
-      multi_json (~> 1.0)
-    ffi (1.9.0)
-    fssm (0.2.10)
-    haml (4.0.3)
-      tilt
-    highline (1.6.20)
-    hike (1.2.3)
-    i18n (0.6.5)
-    kramdown (1.2.0)
-    libv8 (3.16.14.3)
-    listen (1.3.1)
+      compass-core (~> 1.0.1)
+      compass-import-once (~> 1.0.5)
       rb-fsevent (>= 0.9.3)
       rb-inotify (>= 0.9)
-      rb-kqueue (>= 0.2)
-    middleman (3.1.6)
-      coffee-script (~> 2.2.0)
-      compass (>= 0.12.2)
-      execjs (~> 1.4.0)
-      haml (>= 3.1.6)
+      sass (>= 3.3.13, < 3.5)
+    compass-core (1.0.1)
+      multi_json (~> 1.0)
+      sass (>= 3.3.0, < 3.5)
+    compass-import-once (1.0.5)
+      sass (>= 3.2, < 3.5)
+    daemons (1.1.9)
+    em-websocket (0.5.1)
+      eventmachine (>= 0.12.9)
+      http_parser.rb (~> 0.6.0)
+    erubis (2.7.0)
+    eventmachine (1.0.3)
+    execjs (2.2.2)
+    ffi (1.9.6)
+    haml (4.0.5)
+      tilt
+    hike (1.2.3)
+    hitimes (1.2.2)
+    hooks (0.4.0)
+      uber (~> 0.0.4)
+    htmlcompressor (0.1.2)
+    http_parser.rb (0.6.0)
+    i18n (0.6.11)
+    json (1.8.1)
+    kramdown (1.5.0)
+    less (2.6.0)
+      commonjs (~> 0.2.7)
+    libv8 (3.16.14.7)
+    listen (2.7.11)
+      celluloid (>= 0.15.2)
+      rb-fsevent (>= 0.9.3)
+      rb-inotify (>= 0.9)
+    middleman (3.3.6)
+      coffee-script (~> 2.2)
+      compass (>= 1.0.0, < 2.0.0)
+      compass-import-once (= 1.0.5)
+      execjs (~> 2.0)
+      haml (>= 4.0.5)
       kramdown (~> 1.2)
-      middleman-core (= 3.1.6)
-      middleman-more (= 3.1.6)
+      middleman-core (= 3.3.6)
       middleman-sprockets (>= 3.1.2)
-      sass (>= 3.1.20)
-      uglifier (~> 2.1.0)
-    middleman-core (3.1.6)
-      activesupport (~> 3.2.6)
+      sass (>= 3.4.0, < 4.0)
+      uglifier (~> 2.5)
+    middleman-core (3.3.6)
+      activesupport (~> 4.1.0)
       bundler (~> 1.1)
-      i18n (~> 0.6.1)
-      listen (~> 1.1)
-      rack (>= 1.4.5)
-      rack-test (~> 0.6.1)
+      erubis
+      hooks (~> 0.3)
+      i18n (~> 0.6.9)
+      listen (>= 2.7.9, < 3.0)
+      padrino-helpers (~> 0.12.3)
+      rack (>= 1.4.5, < 2.0)
+      rack-test (~> 0.6.2)
       thor (>= 0.15.2, < 2.0)
-      tilt (~> 1.3.6)
-    middleman-minify-html (3.1.1)
-      middleman-core (~> 3.0)
-    middleman-more (3.1.6)
-    middleman-sprockets (3.1.4)
-      middleman-core (>= 3.0.14)
-      middleman-more (>= 3.0.14)
-      sprockets (~> 2.1)
-      sprockets-helpers (~> 1.0.0)
-      sprockets-sass (~> 1.0.0)
-    multi_json (1.8.2)
+      tilt (~> 1.4.1, < 2.0)
+    middleman-livereload (3.3.4)
+      em-websocket (~> 0.5.1)
+      middleman-core (~> 3.2)
+      rack-livereload (~> 0.3.15)
+    middleman-minify-html (3.4.0)
+      htmlcompressor (~> 0.1.0)
+      middleman-core (>= 3.2)
+    middleman-sprockets (3.3.10)
+      middleman-core (~> 3.3)
+      sprockets (~> 2.12.1)
+      sprockets-helpers (~> 1.1.0)
+      sprockets-sass (~> 1.2.0)
+    middleman-syntax (2.0.0)
+      middleman-core (~> 3.2)
+      rouge (~> 1.0)
+    minitest (5.4.2)
+    multi_json (1.10.1)
+    padrino-helpers (0.12.4)
+      i18n (~> 0.6, >= 0.6.7)
+      padrino-support (= 0.12.4)
+      tilt (~> 1.4.1)
+    padrino-support (0.12.4)
+      activesupport (>= 3.1)
     rack (1.5.2)
     rack-contrib (1.1.0)
       rack (>= 0.9.1)
+    rack-livereload (0.3.15)
+      rack
+    rack-rewrite (1.5.0)
+    rack-ssl-enforcer (0.2.8)
     rack-test (0.6.2)
       rack (>= 1.0)
-    rb-fsevent (0.9.3)
-    rb-inotify (0.9.2)
+    rb-fsevent (0.9.4)
+    rb-inotify (0.9.5)
       ffi (>= 0.5.0)
-    rb-kqueue (0.2.0)
-      ffi (>= 0.5.0)
-    redcarpet (3.0.0)
+    redcarpet (3.2.0)
     ref (1.0.5)
-    sass (3.2.12)
-    sprockets (2.10.0)
+    rouge (1.7.2)
+    sass (3.4.6)
+    sprockets (2.12.2)
       hike (~> 1.2)
       multi_json (~> 1.0)
       rack (~> 1.0)
       tilt (~> 1.1, != 1.3.0)
-    sprockets-helpers (1.0.1)
+    sprockets-helpers (1.1.0)
       sprockets (~> 2.0)
-    sprockets-sass (1.0.2)
+    sprockets-sass (1.2.0)
       sprockets (~> 2.0)
       tilt (~> 1.1)
-    therubyracer (0.12.0)
+    therubyracer (0.12.1)
       libv8 (~> 3.16.14.0)
       ref
-    thin (1.5.1)
-      daemons (>= 1.0.9)
-      eventmachine (>= 0.12.6)
-      rack (>= 1.0.0)
-    thor (0.18.1)
-    tilt (1.3.7)
-    uglifier (2.1.2)
+    thin (1.6.3)
+      daemons (~> 1.0, >= 1.0.9)
+      eventmachine (~> 1.0)
+      rack (~> 1.0)
+    thor (0.19.1)
+    thread_safe (0.3.4)
+    tilt (1.4.1)
+    timers (4.0.1)
+      hitimes
+    tzinfo (1.2.2)
+      thread_safe (~> 0.1)
+    uber (0.0.10)
+    uglifier (2.5.3)
       execjs (>= 0.3.0)
-      multi_json (~> 1.0, >= 1.0.2)
+      json (>= 1.8.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  highline (~> 1.6.15)
-  middleman (~> 3.1.5)
-  middleman-minify-html (~> 3.1.1)
-  rack-contrib (~> 1.1.0)
-  redcarpet (~> 3.0.0)
-  therubyracer (~> 0.12.0)
-  thin (~> 1.5.0)
+  middleman-hashicorp!
diff --git a/website/Vagrantfile b/website/Vagrantfile
new file mode 100644
index 000000000..b8da4b2db
--- /dev/null
+++ b/website/Vagrantfile
@@ -0,0 +1,25 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+$script = <<SCRIPT
+sudo apt-get -y update
+
+# RVM/Ruby
+sudo apt-get -y install curl
+curl -sSL https://get.rvm.io | bash -s stable
+. ~/.bashrc
+. ~/.bash_profile
+rvm install 2.0.0
+rvm --default use 2.0.0
+
+# Middleman deps
+cd /vagrant
+bundle
+SCRIPT
+
+Vagrant.configure(2) do |config|
+  config.vm.box = "chef/ubuntu-12.04"
+  config.vm.network "private_network", ip: "33.33.30.10"
+  config.vm.provision "shell", inline: $script, privileged: false
+  config.vm.synced_folder ".", "/vagrant", type: "rsync"
+end
diff --git a/website/config.rb b/website/config.rb
index e51b909a3..3e15896af 100644
--- a/website/config.rb
+++ b/website/config.rb
@@ -1,93 +1,12 @@
-require "net/http"
-
-raise "PACKER_VERSION must be set." if !ENV["PACKER_VERSION"]
-
-#-------------------------------------------------------------------------
-# Download the list of Packer downloads
-#-------------------------------------------------------------------------
-
-$packer_files = {}
-$packer_os = []
-
-if !ENV["PACKER_DISABLE_DOWNLOAD_FETCH"]
-  raise "BINTRAY_API_KEY must be set." if !ENV["BINTRAY_API_KEY"]
-  http = Net::HTTP.new("dl.bintray.com", 80)
-  req = Net::HTTP::Get.new("/mitchellh/packer/")
-  req.basic_auth "mitchellh", ENV["BINTRAY_API_KEY"]
-  response = http.request(req)
-
-  response.body.split("\n").each do |line|
-    next if line !~ /\/mitchellh\/packer\/(#{Regexp.quote(ENV["PACKER_VERSION"])}.+?)'/
-    filename = $1.to_s
-    os = filename.split("_")[1]
-    next if os == "SHA256SUMS"
-
-    $packer_files[os] ||= []
-    $packer_files[os] << filename
-  end
-
-  $packer_os = ["darwin", "linux", "windows"] & $packer_files.keys
-  $packer_os += $packer_files.keys
-  $packer_os.uniq!
-
-  $packer_files.each do |key, value|
-    value.sort!
-  end
-end
-
 #-------------------------------------------------------------------------
 # Configure Middleman
 #-------------------------------------------------------------------------
 
-set :css_dir, 'stylesheets'
-set :js_dir, 'javascripts'
-set :images_dir, 'images'
+set :base_url, "https://www.packer.io/"
 
-# Use the RedCarpet Markdown engine
-set :markdown_engine, :redcarpet
-set :markdown,
-    :fenced_code_blocks => true,
-    :with_toc_data => true
-
-# Build-specific configuration
-configure :build do
-  activate :asset_hash
-  activate :minify_css
-  activate :minify_html
-  activate :minify_javascript
-end
-
-#-------------------------------------------------------------------------
-# Helpers
-#-------------------------------------------------------------------------
-helpers do
-  def download_arch(file)
-    parts = file.split("_")
-    return "" if parts.length != 3
-    parts[2].split(".")[0]
-  end
-
-  def download_os_human(os)
-    if os == "darwin"
-      return "Mac OS X"
-    elsif os == "freebsd"
-      return "FreeBSD"
-    elsif os == "openbsd"
-      return "OpenBSD"
-    elsif os == "Linux"
-      return "Linux"
-    elsif os == "windows"
-      return "Windows"
-    else
-      return os
-    end
-  end
-
-  def download_url(file)
-    "https://dl.bintray.com/mitchellh/packer/#{file}"
-  end
-
-  def latest_version
-    ENV["PACKER_VERSION"]
-  end
+activate :hashicorp do |h|
+  h.version      = ENV["PACKER_VERSION"]
+  h.bintray_repo = 'mitchellh/packer'
+  h.bintray_user = 'mitchellh'
+  h.bintray_key  = ENV['BINTRAY_API_KEY']
 end
diff --git a/website/config.ru b/website/config.ru
index 5cf4e322d..fd8f01d6c 100644
--- a/website/config.ru
+++ b/website/config.ru
@@ -12,7 +12,7 @@ use Rack::Deflater
 # to do.
 use Rack::StaticCache,
   :root => "build",
-  :urls => ["/images", "/javascripts", "/stylesheets"],
+  :urls => ["/assets"],
   :duration => 2,
   :versioning => false
 
diff --git a/website/counter.txt b/website/counter.txt
deleted file mode 100644
index e2b48f13b..000000000
--- a/website/counter.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-Just update this if you want to force a website push and it isn't
-working:
-
-1
diff --git a/website/source/404.html.erb b/website/source/404.html.erb
index fa51e4b8c..e7dcdc5a2 100644
--- a/website/source/404.html.erb
+++ b/website/source/404.html.erb
@@ -1 +1,5 @@
+---
+noindex: true
+---
+
 <h2>Page Not Found</h2>
diff --git a/website/source/fonts/2772B2_0_0.eot b/website/source/assets/fonts/2772B2_0_0.eot
similarity index 100%
rename from website/source/fonts/2772B2_0_0.eot
rename to website/source/assets/fonts/2772B2_0_0.eot
diff --git a/website/source/fonts/2772B2_0_0.ttf b/website/source/assets/fonts/2772B2_0_0.ttf
similarity index 100%
rename from website/source/fonts/2772B2_0_0.ttf
rename to website/source/assets/fonts/2772B2_0_0.ttf
diff --git a/website/source/fonts/2772B2_0_0.woff b/website/source/assets/fonts/2772B2_0_0.woff
similarity index 100%
rename from website/source/fonts/2772B2_0_0.woff
rename to website/source/assets/fonts/2772B2_0_0.woff
diff --git a/website/source/images/arrow-left.png b/website/source/assets/images/arrow-left.png
similarity index 100%
rename from website/source/images/arrow-left.png
rename to website/source/assets/images/arrow-left.png
diff --git a/website/source/images/arrow-right.png b/website/source/assets/images/arrow-right.png
similarity index 100%
rename from website/source/images/arrow-right.png
rename to website/source/assets/images/arrow-right.png
diff --git a/website/source/images/divider.png b/website/source/assets/images/divider.png
similarity index 100%
rename from website/source/images/divider.png
rename to website/source/assets/images/divider.png
diff --git a/website/source/images/down_arrow.png b/website/source/assets/images/down_arrow.png
similarity index 100%
rename from website/source/images/down_arrow.png
rename to website/source/assets/images/down_arrow.png
diff --git a/website/source/images/hero_image.jpg b/website/source/assets/images/hero_image.jpg
similarity index 100%
rename from website/source/images/hero_image.jpg
rename to website/source/assets/images/hero_image.jpg
diff --git a/website/source/images/logo_footer.png b/website/source/assets/images/logo_footer.png
similarity index 100%
rename from website/source/images/logo_footer.png
rename to website/source/assets/images/logo_footer.png
diff --git a/website/source/images/logo_nav.png b/website/source/assets/images/logo_nav.png
similarity index 100%
rename from website/source/images/logo_nav.png
rename to website/source/assets/images/logo_nav.png
diff --git a/website/source/images/screenshots/vmware_and_virtualbox.png b/website/source/assets/images/screenshots/vmware_and_virtualbox.png
similarity index 100%
rename from website/source/images/screenshots/vmware_and_virtualbox.png
rename to website/source/assets/images/screenshots/vmware_and_virtualbox.png
diff --git a/website/source/images/screenshots/works_with.png b/website/source/assets/images/screenshots/works_with.png
similarity index 100%
rename from website/source/images/screenshots/works_with.png
rename to website/source/assets/images/screenshots/works_with.png
diff --git a/website/source/images/user_bbc.png b/website/source/assets/images/user_bbc.png
similarity index 100%
rename from website/source/images/user_bbc.png
rename to website/source/assets/images/user_bbc.png
diff --git a/website/source/images/user_disqus.png b/website/source/assets/images/user_disqus.png
similarity index 100%
rename from website/source/images/user_disqus.png
rename to website/source/assets/images/user_disqus.png
diff --git a/website/source/images/user_edgecast.png b/website/source/assets/images/user_edgecast.png
similarity index 100%
rename from website/source/images/user_edgecast.png
rename to website/source/assets/images/user_edgecast.png
diff --git a/website/source/images/user_expedia.png b/website/source/assets/images/user_expedia.png
similarity index 100%
rename from website/source/images/user_expedia.png
rename to website/source/assets/images/user_expedia.png
diff --git a/website/source/images/works_with_aws.png b/website/source/assets/images/works_with_aws.png
similarity index 100%
rename from website/source/images/works_with_aws.png
rename to website/source/assets/images/works_with_aws.png
diff --git a/website/source/images/works_with_virtual.png b/website/source/assets/images/works_with_virtual.png
similarity index 100%
rename from website/source/images/works_with_virtual.png
rename to website/source/assets/images/works_with_virtual.png
diff --git a/website/source/images/works_with_vmware.png b/website/source/assets/images/works_with_vmware.png
similarity index 100%
rename from website/source/images/works_with_vmware.png
rename to website/source/assets/images/works_with_vmware.png
diff --git a/website/source/assets/javascripts/.keep b/website/source/assets/javascripts/.keep
new file mode 100644
index 000000000..e69de29bb
diff --git a/website/source/assets/stylesheets/_buttons.scss b/website/source/assets/stylesheets/_buttons.scss
new file mode 100644
index 000000000..0edc0c7c4
--- /dev/null
+++ b/website/source/assets/stylesheets/_buttons.scss
@@ -0,0 +1,52 @@
+@mixin button {
+  font-family: $mono;
+  height: $button-height;
+  line-height: $button-height;
+  background-color: transparent;
+  border-width: 2px;
+  border-style: solid;
+  display: block;
+  padding: 0 30px;
+  text-transform: uppercase;
+  letter-spacing: 3px;
+  @include rounded(5px);
+
+  &.spaced {
+    margin-right: 20px;
+  }
+
+  &.primary {
+    color: $green;
+    border-color: $green;
+
+    &:hover {
+      background-color: transparentize($green, .7);
+    }
+
+    &:active {
+      background-color: transparentize($green, .5);
+    }
+  }
+
+  &.secondary {
+    color: $black;
+    border-color: $black;
+
+    &:hover {
+      background-color: transparentize($black, .9);
+    }
+
+    &:active {
+      background-color: transparentize($black, .7);
+    }
+  }
+
+  &.inline {
+    margin: auto $baseline;
+    @include respond-to(mobile) {
+      display: block;
+      width: 100%;
+      margin: $baseline 0;
+    }
+  }
+}
diff --git a/website/source/assets/stylesheets/_columns.scss b/website/source/assets/stylesheets/_columns.scss
new file mode 100644
index 000000000..71f1a099e
--- /dev/null
+++ b/website/source/assets/stylesheets/_columns.scss
@@ -0,0 +1,50 @@
+.container-xs-height {
+  display:table;
+  padding-left:0px;
+  padding-right:0px;
+}
+
+
+.col-xs-height {
+  display:table-cell;
+  float:none;
+}
+
+@media (min-width: 768px) {
+  .container-sm-height {
+    display:table;
+    padding-left:0px;
+    padding-right:0px;
+  }
+
+  .col-sm-height {
+    display:table-cell;
+    float:none;
+  }
+}
+
+@media (min-width: 992px) {
+  .container-md-height {
+    display:table;
+    padding-left:0px;
+    padding-right:0px;
+  }
+
+  .col-md-height {
+    display:table-cell;
+    float:none;
+  }
+}
+
+@media (min-width: 1200px) {
+  .container-lg-height {
+    display:table;
+    padding-left:0px;
+    padding-right:0px;
+  }
+
+  .col-lg-height {
+    display:table-cell;
+    float:none;
+  }
+}
diff --git a/website/source/assets/stylesheets/_components.scss b/website/source/assets/stylesheets/_components.scss
new file mode 100644
index 000000000..c17c9dc1b
--- /dev/null
+++ b/website/source/assets/stylesheets/_components.scss
@@ -0,0 +1,332 @@
+header .header {
+  height: 200px;
+  background: #000000;
+
+  h1 {
+    margin-bottom: -8px;
+    margin-top: 60px;
+    text-transform: uppercase;
+  }
+
+  span {
+    font-size: 20px;
+  }
+}
+
+.hero {
+  height: $hero-height + 100px;
+  background: #000000 image-url('hero_image.jpg') no-repeat;
+  background-position: 35px -40px;
+  background-size: 100%;
+
+  h2 {
+    margin-top: 70px;
+  }
+
+  @media (max-width: $screen-md-max) {
+    height: $hero-height;
+
+    h2 {
+      font-size: 2.1em;
+    }
+  }
+
+  @media (max-width: $screen-sm-max) {
+    height: auto;
+    background: none;
+
+    h2 {
+      margin: 0;
+      padding: 1em;
+    }
+  }
+}
+
+.belt {
+  &.download {
+    background-color: $white;
+    @extend .padded-sm;
+  }
+
+  .download-container {
+    background: image-url('down_arrow.png') no-repeat top left;
+    display: inline-block;
+    min-height: 73px;
+    margin: 0 auto;
+    padding-left: 100px;
+
+    @media (max-width: $screen-sm) {
+      background: none;
+      font-size: 75%;
+      min-height: 50px;
+      padding: 0;
+    }
+  }
+
+  .download-row {
+    text-align: center;
+
+    .small {
+      text-align: left;
+    }
+  }
+
+  h2 {
+    font-family: $serif;
+    font-size: 44px;
+    color: #7bc6b1;
+    margin: 0px;
+    padding: 0px;
+    padding-top: 7px;
+    padding-bottom: 3px;
+    line-height: 1.0;
+    white-space: nowrap;
+
+    &:hover {
+      color: $dark-background;
+    }
+  }
+
+  span {
+    color: $gray-dark;
+  }
+}
+
+.downloads {
+  margin-top: 20px;
+
+  .description {
+    margin-bottom: 20px;
+  }
+
+  .download {
+    border-bottom: 1px solid #b2b2b2;
+    padding-bottom: 15px;
+    margin-bottom: 15px;
+
+    .details {
+      padding-left: 95px;
+
+      li {
+        display: inline-block;
+
+        &:after {
+          content: " | ";
+        }
+
+        &:last-child:after {
+          content: "";
+        }
+      }
+
+      a {
+        font-size: 22px;
+        color: darken($green, 15%);
+
+        &:hover {
+          color: darken($green, 30%);
+        }
+
+        &:active {
+          color: darken($green, 50%);
+        }
+      }
+    }
+
+    .icon {
+      img {
+        width: 75px;
+      }
+    }
+
+    .os-name {
+      font-size: 40px;
+      margin-bottom: -3px;
+    }
+  }
+
+  .poweredby {
+    margin-top: 20px;
+    margin-bottom: 20px;
+
+    img {
+      display: block;
+      margin: 0 auto;
+      width: 122px;
+    }
+  }
+}
+
+.marketting {
+  p {
+    padding-left: 10px;
+    padding-right: 10px;
+    text-align: justify;
+  }
+}
+
+.docs-wrapper {
+  .docs-body {
+    @extend .white-background;
+
+    .docs-content {
+      padding: $docs-top-margin 80px;
+      max-width: 960px;
+      display: block;
+
+      code {
+        background-color: #000;
+        border: 0;
+        color: #b1d631;
+        font-size: 14px;
+      }
+
+      a {
+        color: darken($green, 15%);
+
+        &:hover {
+          color: darken($green, 30%);
+        }
+
+        &:active {
+          color: darken($green, 50%);
+        }
+      }
+
+      ul, ol {
+        list-style-position: inside;
+        margin-top: $baseline;
+        margin-left: 20px;
+        margin-right: 20px;
+
+        li {
+          font-family: $serif;
+          font-size: 17px;
+          line-height: (30/17) !important;
+          margin-bottom: $baseline;
+        }
+      }
+
+      ul {
+        list-style-type: circle;
+      }
+
+      ol {
+        list-style-type: decimal;
+      }
+
+      div.alert {
+        font-family: $serif;
+        font-size: 17px;
+        line-height: 1.5;
+        letter-spacing: 1px;
+        margin-left: -95px;
+        margin-right: -95px;
+        padding-top: 40px;
+        padding-bottom: 40px;
+        padding-left: 80px;
+        padding-right: 80px;
+        border-radius: 0;
+      }
+
+      pre {
+        border: 0;
+        font-size: 14px;
+        margin-left: -95px;
+        margin-right: -95px;
+        padding-top: 40px;
+        padding-bottom: 40px;
+        padding-left: 80px;
+        padding-right: 80px;
+        border-radius: 0;
+      }
+    }
+
+    section {
+      margin-top: $docs-top-margin;
+    }
+
+    h1 {
+      font-size: 40px;
+      line-height: (25/20);
+      text-transform: uppercase;
+    }
+
+    h2 {
+      margin-top: $baseline * 2;
+      text-transform: capitalize;
+    }
+
+    h3 {
+      margin-top: $baseline;
+      text-transform: capitalize;
+      font-size: 26px;
+    }
+  }
+}
+
+.pagination {
+  $border: 1px solid $gray-mid;
+  height: $nav-height;
+  border-top: $border;
+  font-size: 20px;
+  margin: 0 -15px -40px -15px;
+  display: block;
+
+  h4 {
+    display: inline-block;
+    margin-top: ($baseline * 1.7);
+    margin-left: $baseline;
+
+    @include respond-to(mobile) {
+      margin-top: 10px;
+    }
+  }
+
+  span {
+    @include respond-to(mobile) {
+      display: block;
+    }
+  }
+
+  .previous-section,
+  .next-section {
+    height: $nav-height;
+    display: block;
+
+    &:hover {
+      background-color: transparentize($gray-light, .7);
+    }
+  }
+
+  .previous-section {
+    width: $nav-height;
+    border-right: $border;
+    float: left;
+    background: $white image-url('arrow-left.png') no-repeat center center;
+    @include respond-to(mobile) {
+      width: 50%;
+      background-position: left center;
+    }
+  }
+
+  .next-section {
+    background: $white image-url('arrow-right.png') no-repeat center right;
+  }
+}
+
+.people {
+  margin-top: 30px;
+
+  .person {
+    margin-bottom: 30px;
+
+    h3 {
+      text-transform: none;
+    }
+
+    .bio {
+      padding-left: 150px;
+    }
+  }
+}
diff --git a/website/source/assets/stylesheets/_footer.scss b/website/source/assets/stylesheets/_footer.scss
new file mode 100644
index 000000000..7f771340f
--- /dev/null
+++ b/website/source/assets/stylesheets/_footer.scss
@@ -0,0 +1,70 @@
+footer {
+  height: $nav-height;
+  max-height: $nav-height;
+  background-color: $black !important;
+  padding: 0;
+  margin: 0;
+  text-transform: uppercase;
+  color: $white;
+  font-family: $sans;
+  @include respond-to(mobile) {
+    margin-right: -20px;
+    margin-left: -20px;
+  }
+
+	ul {
+  	margin-top: 40px;
+  	@include respond-to(mobile) {
+    	margin-left: $baseline;
+    	margin-top: $baseline;
+    }
+
+		li {
+  		display: inline;
+  		margin-right: 50px;
+  		@include respond-to(mobile) {
+    		margin-right: 20px;
+    		display: list-item;
+      }
+    }
+
+		.hashi-logo {
+  		background: image-url('logo_footer.png') no-repeat center top;
+  		height: 40px;
+  		width: 40px;
+  		background-size: 37px 40px;
+  		text-indent: -999999px;
+  		display: inline-block;
+  		margin-top: -10px;
+  		margin-right: 0;
+  		@include respond-to(mobile) {
+    		margin-top: -50px;
+    		margin-right: $baseline;
+  		}
+		}
+	}
+
+	.active {
+    color: $green;
+	}
+
+	button {
+    margin-top: 20px;
+	}
+}
+
+.page-wrap {
+  min-height: 100%;
+  /* equal to footer height */
+  margin-bottom: -($nav-height);
+}
+
+.page-wrap:after {
+  content: "";
+  display: block;
+}
+
+.page-wrap:after {
+  /* .push must be the same height as footer */
+  height: $nav-height;
+}
diff --git a/website/source/stylesheets/_helpers.scss b/website/source/assets/stylesheets/_helpers.scss
similarity index 56%
rename from website/source/stylesheets/_helpers.scss
rename to website/source/assets/stylesheets/_helpers.scss
index 0c6dba52f..d28b5265c 100644
--- a/website/source/stylesheets/_helpers.scss
+++ b/website/source/assets/stylesheets/_helpers.scss
@@ -23,7 +23,7 @@ $base-line-height: 20px;
 $button-height: 60px;
 
 .center {
-    margin: 0 auto;
+  margin: 0 auto;
 }
 
 .padded-lg {padding: ($baseline * 2) 0;}
@@ -44,68 +44,66 @@ $serif: 'myriad-pro', helvetica, Georgia, serif;
 $sans: 'HeimatStencil-SemiBold', 'Avenir', 'Helvetica Neue', Helvetica, Arial, sans-serif;
 $mono: 'Inconsolata', 'courier new', courier, mono-space;
 
-.serif {font-family: $serif;}
-.sans {font-family: $sans;}
-.mono {font-family: $mono;}
+.serif { font-family: $serif; }
+.sans { font-family: $sans; }
+.mono { font-family: $mono; }
 
-.text-center {text-align: center !important;}
-.text-left {text-align: left !important;}
-.text-right {text-align: right !important;}
+.text-center { text-align: center !important; }
+.text-left { text-align: left !important; }
+.text-right { text-align: right !important; }
 
-.text-green {color: $green;}
+.text-green { color: $green; }
 
-.uppercase {text-transform: uppercase !important;}
+.uppercase { text-transform: uppercase !important; }
 
 @font-face {
     font-family: 'HeimatStencil-SemiBold';
-    src: url('../../fonts/2772B2_0_0.eot');
-    src: url('../../fonts/2772B2_0_0.woff') format('woff'),
-         url('../../fonts/2772B2_0_0.ttf') format('truetype');
+    src: font-url('2772B2_0_0.eot');
+    src: font-url('2772B2_0_0.woff') format('woff'),
+         font-url('2772B2_0_0.ttf') format('truetype');
     font-weight: normal;
     font-style: normal;
 }
 
-
 //color
 .dark-background {
-    background-color: #000;
-    color: $white;
+  background-color: #000;
+  color: $white;
 
 	a {
-	color: inherit;
-		&:hover {
-		color: $green;
+    color: inherit;
+
+    &:hover {
+		  color: $green;
 		}
+
 		&:active {
-		color: darken($green, 30%);
+		  color: darken($green, 30%);
 		}
 	}
 }
 
 .white-background {
-background-color: $white;
+  background-color: $white;
 }
 
-
 //elements
 .divider {
-background: url(/images/divider.png) no-repeat center bottom;
-height: 70px;
-width: 70px;
-background-size: 70px 70px;
-display: table-cell;
-text-align: center;
-vertical-align: middle;
+  background: image-url('divider.png') no-repeat center bottom;
+  height: 70px;
+  width: 70px;
+  background-size: 70px 70px;
+  display: table-cell;
+  text-align: center;
+  vertical-align: middle;
 }
 
 .packer {
-color: $orange;
-font-size: 20px;
+  color: $orange;
+  font-size: 20px;
 
-	a:hover,
-	a:active,
-	a:visited {
-	color: inherit;
+	a:hover, a:active, a:visited {
+    color: inherit;
 	}
 }
 
@@ -141,39 +139,39 @@ $break-lg: 980px;
 
 /* utlities */
 .d {
-border-bottom: 1px solid $red;
-border-top: 1px solid $red;
-background-color: transparentize($red, .9);
+  border-bottom: 1px solid $red;
+  border-top: 1px solid $red;
+  background-color: transparentize($red, .9);
 }
 
 .hyphenate {
--webkit-hyphens: auto;
--moz-hyphens: auto;
-hyphens: auto;
+  -webkit-hyphens: auto;
+  -moz-hyphens: auto;
+  hyphens: auto;
 }
 
 .full-width {
-margin-right: -20px;
-margin-left: -20px;
+  margin-right: -20px;
+  margin-left: -20px;
 }
 
 .add-transition {
-transition: all .1s ease-in-out;
--moz-transition: all .1s ease-in-out;
--webkit-transition: all .1s ease-in-out;
--o-transition: all .1s ease-in-out;
+  -webkit-transition: all .1s ease-in-out;
+     -moz-transition: all .1s ease-in-out;
+       -o-transition: all .1s ease-in-out;
+          transition: all .1s ease-in-out;
 }
 
 @mixin opacity($opacity) {
--khtml-opacity: $opacity;
--moz-opacity: $opacity;
-opacity: $opacity;
+  -khtml-opacity: $opacity;
+    -moz-opacity: $opacity;
+         opacity: $opacity;
 }
 
 @mixin transform-scale($value) {
-	 -moz-transform: scale($value);
--webkit-transform: scale($value);
-				transform: scale($value);
+  -webkit-transform: scale($value);
+  	 -moz-transform: scale($value);
+  				transform: scale($value);
 }
 
 @mixin transition($type, $speed, $easing) {
@@ -184,8 +182,8 @@ opacity: $opacity;
 }
 
 @mixin rounded($radius) {
--moz-border-radius: $radius;
--webkit-border-radius: $radius;
--khtml-border-radius: $radius;
-border-radius: $radius;
+  -webkit-border-radius: $radius;
+     -moz-border-radius: $radius;
+   -khtml-border-radius: $radius;
+          border-radius: $radius;
 }
diff --git a/website/source/assets/stylesheets/_nav.scss b/website/source/assets/stylesheets/_nav.scss
new file mode 100644
index 000000000..13acc3ff2
--- /dev/null
+++ b/website/source/assets/stylesheets/_nav.scss
@@ -0,0 +1,70 @@
+nav {
+  height: $nav-height;
+  height: $nav-height;
+  padding: 0;
+  margin: 0;
+  min-width: 940px;
+  text-transform: uppercase;
+  color: $white;
+  font-family: $sans;
+  font-size: 16px;
+  border-bottom: 1px solid $border-dark;
+
+  ul {
+    margin-top: ($baseline * 2);
+    margin-left: $nav-height;
+
+    li {
+      display: inline-block;
+      margin-right: 50px;
+    }
+  }
+
+  .packer-logo {
+    background: image-url('logo_nav.png') no-repeat center top;
+    height: 80px;
+    width: 80px;
+    background-size: 34px 50px;
+    text-indent: -999999px;
+    display: inline-block;
+    margin-top: 25px;
+  }
+
+  @media (min-width: $screen-md-min) {
+    ul {
+      li {
+        &.featured {
+          margin: -20px 0 0 10px;
+          float: right;
+
+          a {
+            @include button;
+            font-weight: bold;
+          }
+        }
+      }
+    }
+  }
+
+  @media (max-width: $screen-sm-max) {
+    height: auto;
+    padding: 0;
+    min-width: auto;
+
+    ul {
+      margin: 1em 0 1em 80px;
+
+      li {
+        display: block;
+        margin: 0;
+        padding: 1em;
+      }
+    }
+  }
+
+  @media (max-width: $screen-xs-max) {
+    button {
+
+    }
+  }
+}
diff --git a/website/source/assets/stylesheets/_reset.scss b/website/source/assets/stylesheets/_reset.scss
new file mode 100644
index 000000000..4ebb5fd27
--- /dev/null
+++ b/website/source/assets/stylesheets/_reset.scss
@@ -0,0 +1,23 @@
+form, input, textarea, button {
+  padding: 0;
+  margin: 0;
+  vertical-align: middle;
+  border: 0;
+  box-shadow: none;
+  -moz-border-radius: 0;
+  -webkit-border-radius: 0;
+  -khtml-border-radius: 0;
+  border-radius: 0;
+  background-color: transparent;
+  font-family: $mono;
+  font-size: $base-font-size;
+  line-height: 1.0;
+  color: inherit;
+
+	&:focus {
+  	line-height: 1.0;
+  	box-shadow: none !important;
+  	outline: none;
+  	vertical-align: middle;
+	}
+}
diff --git a/website/source/assets/stylesheets/_sidebar.scss b/website/source/assets/stylesheets/_sidebar.scss
new file mode 100644
index 000000000..0814efdcf
--- /dev/null
+++ b/website/source/assets/stylesheets/_sidebar.scss
@@ -0,0 +1,37 @@
+.sidebar {
+  $border: 1px solid $gray-dark;
+  font-size: 16px;
+  font-family: $mono;
+  color: $gray-light;
+  background-color: $sidebar-background-color;
+  min-height: 100%;
+
+  h2 {
+    color: $green;
+    text-transform: uppercase;
+    padding: $docs-top-margin 20px 0;
+  }
+
+  h4 {
+    color: $white;
+    text-transform: uppercase;
+    margin-bottom: -10px;
+  }
+
+  ul {
+    @extend .padded-sm;
+
+    li {
+      border-bottom: $border;
+      padding: 15px 0;
+      text-align: left;
+    }
+
+    li > * {
+      padding: auto 20px;
+      margin-left: 20px;
+      display: block;
+      width: 100%;
+    }
+  }
+}
diff --git a/website/source/assets/stylesheets/_styles.scss b/website/source/assets/stylesheets/_styles.scss
new file mode 100644
index 000000000..1ce4a566c
--- /dev/null
+++ b/website/source/assets/stylesheets/_styles.scss
@@ -0,0 +1,173 @@
+* {
+  margin: 0;
+}
+
+html,
+body {
+  margin: 0;
+  height: 100%;
+}
+
+html {
+  -webkit-tap-highlight-color: transparent;
+  -webkit-font-smoothing: antialiased;
+}
+
+body {
+  background-color: $background;
+  font-family: $sans;
+  letter-spacing: 1px;
+  font-size: $base-font-size;
+  line-height: $base-line-height;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  letter-spacing: 2px;
+  font-weight: normal;
+}
+
+h1 {
+  font-family: $sans;
+  font-size: 70px;
+  line-height: (80/70);
+  @include respond-to(mobile) {
+    font-size: 50px;
+    line-height: (50/45);
+  }
+}
+
+h2 {
+  font-family: $sans;
+  font-size: 40px;
+  line-height: (50/40);
+
+  &.has-dividers {
+    //overflow: auto !important;
+    display: table-cell;
+    text-align: center;
+    vertical-align: middle;
+    @include respond-to(mobile) {
+      display: block;
+    }
+  }
+}
+
+h3 {
+  font-family: $sans;
+  font-size: 20px;
+  line-height: (30/20);
+}
+
+h4 {
+  font-family: $mono;
+  font-size: 20px;
+  line-height: (30/20);
+}
+
+h5 {
+  font-family: $sans;
+  font-size: 16px;
+  line-height: (22/16);
+}
+
+h6 {
+  font-family: $mono;
+  font-size: 16px;
+  line-height: (22/16);
+}
+
+p {
+  font-family: $serif;
+  font-size: 17px;
+  line-height: (30/17);
+  letter-spacing: 1px;
+
+  &.large-text {
+    font-size: 20px;
+    line-height: (35/20);
+  }
+
+  a {
+    color: $green;
+
+    &:hover {
+      color: darken($green, 30%);
+    }
+
+    &:active {
+      color: darken($green, 50%);
+    }
+  }
+}
+
+a {
+  color: inherit;
+  text-decoration: none;
+
+  &:hover {
+    color: inherit;
+    text-decoration: none;
+  }
+}
+
+dt {
+  font-size: 18px;
+}
+
+dd {
+  font-family: $serif;
+  font-size: 17px;
+  line-height: 1.5;
+  letter-spacing: 1px;
+  margin-bottom: 30px;
+}
+
+ul, ol {
+  margin: 0;
+  padding: 0;
+  list-style-type: none;
+}
+
+em {
+  font-style: italic;
+}
+
+strong {
+  font-weight: bold;
+}
+
+small, .small {
+  font-size: 13px;
+}
+
+hr {
+  margin: ($baseline * 2) 0;
+  border-color: $gray-mid;
+  border-bottom: 0;
+}
+
+pre {
+  background-color: $black;
+  color: $white;
+  margin: $baseline 0;
+}
+
+table {
+  font-family: $mono;
+  margin: ($baseline * 2) 0;
+  color: $gray-dark;
+
+  th {
+    color: $black;
+    font-weight: normal !important;
+  }
+}
+
+::selection {
+  background: #ffff00; /* Safari */
+  color: $black;
+}
+::-moz-selection {
+  background: #ffff00; /* Firefox */
+  color: $black;
+}
diff --git a/website/source/assets/stylesheets/application.scss b/website/source/assets/stylesheets/application.scss
new file mode 100644
index 000000000..581c8c217
--- /dev/null
+++ b/website/source/assets/stylesheets/application.scss
@@ -0,0 +1,15 @@
+@import "bootstrap-sprockets";
+@import "bootstrap";
+
+@import url("//fonts.googleapis.com/css?family=Inconsolata");
+
+@import "_helpers";
+@import "_reset";
+
+@import "_columns";
+@import "_buttons";
+@import "_styles";
+@import "_nav";
+@import "_footer";
+@import "_components";
+@import "_sidebar";
diff --git a/website/source/community/index.html.markdown b/website/source/community/index.html.markdown
index f5b261732..89c37ef03 100644
--- a/website/source/community/index.html.markdown
+++ b/website/source/community/index.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "community"
 page_title: "Community"
+description: |-
+  Packer is a new project with a growing community. Despite this, there are dedicated users willing to help through various mediums.
 ---
 
 # Community
@@ -66,12 +68,19 @@ list as contributors come and go.
 		<div class="bio">
 			<h3>Ross Smith II (<a href="https://github.com/rasa" target="_blank">@rasa</a>)</h3>
 			<p>
-<a href="http://smithii.com/" target="_blank">Ross Smith</a> maintains our VMWare builder on Windows, and provides other valuable assistance.
+<a href="http://smithii.com/" target="_blank">Ross Smith</a> maintains our VMware builder on Windows, and provides other valuable assistance.
 Ross is an open source enthusist, published author, and freelance consultant.</p>
 		</div>
 	</div>
 
-
+	<div class="person">
+		<img class="pull-left" src="http://www.gravatar.com/avatar/c9f6bf7b5b865012be5eded656ebed7d.png?s=125">
+		<div class="bio">
+			<h3>Rickard von Essen<br/>(<a href="https://github.com/rickard-von-essen" target="_blank">@rickard-von-essen</a>)</h3>
+			<p>
+Rickard von Essen maintains our Parallels Desktop builder. Rickard is an polyglot programmer and consults on Continuous Delivery.</p>
+		</div>
+	</div>
 
 	<div class="clearfix"></div>
 </div>
diff --git a/website/source/docs/basics/terminology.html.markdown b/website/source/docs/basics/terminology.html.markdown
index e56f48c03..4fce2cc79 100644
--- a/website/source/docs/basics/terminology.html.markdown
+++ b/website/source/docs/basics/terminology.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Packer Terminology"
+description: |-
+  There are a handful of terms used throughout the Packer documentation where the meaning may not be immediately obvious if you haven't used Packer before. Luckily, there are relatively few. This page documents all the terminology required to understand and use Packer. The terminology is in alphabetical order for easy referencing.
 ---
 
 # Packer Terminology
@@ -10,49 +13,42 @@ Luckily, there are relatively few. This page documents all the terminology
 required to understand and use Packer. The terminology is in alphabetical
 order for easy referencing.
 
-<a class="term" id="term-artifact"></a>
-**Artifacts** are the results of a single [build](#term-build), and are
-usually a set of IDs or files to represent a machine image. Every [builder](#term-builder)
-produces a single artifact. As an example, in the case of the Amazon EC2 builder,
-the artifact is a set of AMI IDs (one per region). For the VMware builder,
-the artifact is a directory of files comprising the created virtual machine.
+- `Artifacts` are the results of a single build, and are usually a set of IDs
+or files to represent a machine image. Every builder produces a single
+artifact. As an example, in the case of the Amazon EC2 builder, the artifact is
+a set of AMI IDs (one per region). For the VMware builder, the artifact is a
+directory of files comprising the created virtual machine.
 
-<a class="term" id="term-build"></a>
-**Builds** are a single task that eventually produces an image for a single
-platform. Multiple builds run in parallel. Example usage in a sentence: "The Packer build
-produced an AMI to run our web application." Or: "Packer is running the builds
-now for VMware, AWS, and VirtualBox."
+- `Builds` are a single task that eventually produces an image for a single
+platform. Multiple builds run in parallel. Example usage in a
+sentence: "The Packer build produced an AMI to run our web application."
+Or: "Packer is running the builds now for VMware, AWS, and VirtualBox."
 
-<a class="term" id="term-builder"></a>
-**Builders** are components of Packer that are able to create a machine
+- `Builders` are components of Packer that are able to create a machine
 image for a single platform. Builders read in some configuration and use
-that to run and generate a machine image. A builder is invoked as part of a [build](#term-build)
-in order to create the actual resulting images. Example builders include
+that to run and generate a machine image. A builder is invoked as part of a
+build in order to create the actual resulting images. Example builders include
 VirtualBox, VMware, and Amazon EC2. Builders can be created and added to
 Packer in the form of plugins.
 
-<a class="term" id="term-command"></a>
-**Commands** are sub-commands for the `packer` program that perform some
-job. An example some command is "build", which is invoked as `packer build`.
+- `Commands` are sub-commands for the `packer` program that perform some
+job. An example command is "build", which is invoked as `packer build`.
 Packer ships with a set of commands out of the box in order to define
-its [command-line interface](#). Commands can also be created and added to
+its command-line interface. Commands can also be created and added to
 Packer in the form of plugins.
 
-<a class="term" id="term-post-processor"></a>
-**Post-processors** are components of Packer that take the result of
-a [builder](#term-builder) or another post-processor and process that to
-create a new [artifact](#term-artifact). Examples of post-processors are
+- `Post-processors` are components of Packer that take the result of
+a builder or another post-processor and process that to
+create a new artifact. Examples of post-processors are
 compress to compress artifacts, upload to upload artifacts, etc.
 
-<a class="term" id="term-provisioner"></a>
-**Provisioners** are components of Packer that install and configure
+- `Provisioners` are components of Packer that install and configure
 software within a running machine prior to that machine being turned
 into a static image. They perform the major work of making the image contain
 useful software. Example provisioners include shell scripts, Chef, Puppet,
 etc.
 
-<a class="term" id="term-template"></a>
-**Templates** are JSON files which define one or more [builds](#term-build)
+- `Templates` are JSON files which define one or more builds
 by configuring the various components of Packer. Packer is able to read a
 template and use that information to create multiple machine images in
 parallel.
diff --git a/website/source/docs/builders/amazon-chroot.html.markdown b/website/source/docs/builders/amazon-chroot.html.markdown
index a2bd21aaf..41235496e 100644
--- a/website/source/docs/builders/amazon-chroot.html.markdown
+++ b/website/source/docs/builders/amazon-chroot.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Amazon AMI Builder (chroot)"
+description: |-
+  The `amazon-chroot` Packer builder is able to create Amazon AMIs backed by an EBS volume as the root device. For more information on the difference between instance storage and EBS-backed instances, storage for the root device section in the EC2 documentation.
 ---
 
 # AMI Builder (chroot)
 
 Type: `amazon-chroot`
 
-The `amazon-chroot` builder is able to create Amazon AMIs backed by
+The `amazon-chroot` Packer builder is able to create Amazon AMIs backed by
 an EBS volume as the root device. For more information on the difference
 between instance storage and EBS-backed instances, see the
 ["storage for the root device" section in the EC2 documentation](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ComponentsAMIs.html#storage-for-the-root-device).
@@ -17,12 +19,10 @@ this builder is able to build an EBS-backed AMI without launching a new
 EC2 instance. This can dramatically speed up AMI builds for organizations
 who need the extra fast build.
 
-<div class="alert alert-block alert-warn">
-<p><strong>This is an advanced builder.</strong> If you're just getting
+~> **This is an advanced builder** If you're just getting
 started with Packer, we recommend starting with the
-<a href="/docs/builders/amazon-ebs.html">amazon-ebs builder</a>, which is
-much easier to use.</p>
-</div>
+[amazon-ebs builder](/docs/builders/amazon-ebs.html), which is
+much easier to use.
 
 The builder does _not_ manage AMIs. Once it creates an AMI and stores it
 in your account, it is up to you to use, delete, etc. the AMI.
@@ -51,11 +51,11 @@ There are many configuration options available for the builder. They are
 segmented below into two categories: required and optional parameters. Within
 each category, the available configuration keys are alphabetized.
 
-Required:
+### Required:
 
 * `access_key` (string) - The access key used to communicate with AWS.
-  If not specified, Packer will attempt to read this from environmental
-  variables `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` (in that order).
+  If not specified, Packer will use the environment variables
+  `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` (in that order), if set.
   If the environmental variables aren't set and Packer is running on
   an EC2 instance, Packer will check the instance metadata for IAM role
   keys.
@@ -66,8 +66,8 @@ Required:
   [configuration templates](/docs/templates/configuration-templates.html) for more info)
 
 * `secret_key` (string) - The secret key used to communicate with AWS.
-  If not specified, Packer will attempt to read this from environmental
-  variables `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` (in that order).
+  If not specified, Packer will use the environment variables
+  `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` (in that order), if set.
   If the environmental variables aren't set and Packer is running on
   an EC2 instance, Packer will check the instance metadata for IAM role
   keys.
@@ -76,37 +76,43 @@ Required:
   and provisioned on the currently running instance. This must be an
   EBS-backed AMI with a root volume snapshot that you have access to.
 
-Optional:
+### Optional:
+
+* `ami_description` (string) - The description to set for the resulting
+  AMI(s). By default this description is empty.
+
+* `ami_groups` (array of strings) - A list of groups that have access
+  to launch the resulting AMI(s). By default no groups have permission
+  to launch the AMI. `all` will make the AMI publicly accessible.
+
+* `ami_product_codes` (array of strings) - A list of product codes to
+  associate with the AMI. By default no product codes are associated with
+  the AMI.
+
+* `ami_regions` (array of strings) - A list of regions to copy the AMI to.
+  Tags and attributes are copied along with the AMI. AMI copying takes time
+  depending on the size of the AMI, but will generally take many minutes.
+
+* `ami_users` (array of strings) - A list of account IDs that have access
+  to launch the resulting AMI(s). By default no additional users other than the user
+  creating the AMI has permissions to launch it.
 
 * `ami_virtualization_type` (string) - The type of virtualization for the AMI
   you are building. This option is required to register HVM images. Can be
   "paravirtual" (default) or "hvm".
 
-* `ami_description` (string) - The description to set for the resulting
-  AMI(s). By default this description is empty.
-
-* `ami_groups` (array of string) - A list of groups that have access
-  to launch the resulting AMI(s). By default no groups have permission
-  to launch the AMI. `all` will make the AMI publicly accessible.
-
-* `ami_product_codes` (array of string) - A list of product codes to
-  associate with the AMI. By default no product codes are associated with
-  the AMI.
-
-* `ami_regions` (array of string) - A list of regions to copy the AMI to.
-  Tags and attributes are copied along with the AMI. AMI copying takes time
-  depending on the size of the AMI, but will generally take many minutes.
-
-* `ami_users` (array of string) - A list of account IDs that have access
-  to launch the resulting AMI(s). By default no additional users other than the user
-  creating the AMI has permissions to launch it.
-
-* `chroot_mounts` (list of list of strings) - This is a list of additional
+* `chroot_mounts` (array of array of strings) - This is a list of additional
   devices to mount into the chroot environment. This configuration parameter
   requires some additional documentation which is in the "Chroot Mounts" section
   below. Please read that section for more information on how to use this.
 
-* `copy_files` (list of strings) - Paths to files on the running EC2 instance
+* `command_wrapper` (string) - How to run shell commands. This
+  defaults to "{{.Command}}". This may be useful to set if you want to set
+  environmental variables or perhaps run it with `sudo` or so on. This is a
+  configuration template where the `.Command` variable is replaced with the
+  command to be run.
+
+* `copy_files` (array of strings) - Paths to files on the running EC2 instance
   that will be copied into the chroot environment prior to provisioning.
   This is useful, for example, to copy `/etc/resolv.conf` so that DNS lookups
   work.
@@ -115,11 +121,8 @@ Optional:
   of the source AMI will be attached. This defaults to "" (empty string),
   which forces Packer to find an open device automatically.
 
-* `command_wrapper` (string) - How to run shell commands. This
-  defaults to "{{.Command}}". This may be useful to set if you want to set
-  environmental variables or perhaps run it with `sudo` or so on. This is a
-  configuration template where the `.Command` variable is replaced with the
-  command to be run.
+* `enhanced_networking` (boolean) - Enable enhanced networking (SriovNetSupport) on
+  HVM-compatible AMIs.
 
 * `mount_path` (string) - The path where the volume will be mounted. This is
   where the chroot environment will be. This defaults to
@@ -133,7 +136,7 @@ Optional:
 
 Here is a basic example. It is completely valid except for the access keys:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "amazon-chroot",
   "access_key": "YOUR KEY HERE",
@@ -141,7 +144,7 @@ Here is a basic example. It is completely valid except for the access keys:
   "source_ami": "ami-e81d5881",
   "ami_name": "packer-amazon-chroot {{timestamp}}"
 }
-</pre>
+```
 
 ## Chroot Mounts
 
@@ -159,14 +162,14 @@ These default mounts are usually good enough for anyone and are sane
 defaults. However, if you want to change or add the mount points, you may
 using the `chroot_mounts` configuration. Here is an example configuration:
 
-<pre class="prettyprint">
+```javascript
 {
   "chroot_mounts": [
     ["proc", "proc", "/proc"],
     ["bind", "/dev", "/dev"]
   ]
 }
-</pre>
+```
 
 `chroot_mounts` is a list of a 3-tuples of strings. The three components
 of the 3-tuple, in order, are:
@@ -197,7 +200,7 @@ the filesystem.
 For debian based distributions you can setup a [policy-rc.d](http://people.debian.org/~hmh/invokerc.d-policyrc.d-specification.txt) file which will
 prevent packages installed by your provisioners from starting services:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "shell",
   "inline": [
@@ -206,11 +209,13 @@ prevent packages installed by your provisioners from starting services:
     "chmod a+x /usr/sbin/policy-rc.d"
   ]
 },
-# ...
+
+// ...
+
 {
   "type": "shell",
   "inline": [
     "rm -f /usr/sbin/policy-rc.d"
   ]
 }
-</pre>
+```
diff --git a/website/source/docs/builders/amazon-ebs.html.markdown b/website/source/docs/builders/amazon-ebs.html.markdown
index 58a43b47f..a52501986 100644
--- a/website/source/docs/builders/amazon-ebs.html.markdown
+++ b/website/source/docs/builders/amazon-ebs.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Amazon AMI Builder (EBS backed)"
+description: |-
+  The `amazon-ebs` Packer builder is able to create Amazon AMIs backed by EBS volumes for use in EC2. For more information on the difference betwen EBS-backed instances and instance-store backed instances, see the storage for the root device section in the EC2 documentation.
 ---
 
 # AMI Builder (EBS backed)
 
 Type: `amazon-ebs`
 
-The `amazon-ebs` builder is able to create Amazon AMIs backed by EBS
+The `amazon-ebs` Packer builder is able to create Amazon AMIs backed by EBS
 volumes for use in [EC2](http://aws.amazon.com/ec2/). For more information
 on the difference betwen EBS-backed instances and instance-store backed
 instances, see the
@@ -29,11 +31,11 @@ There are many configuration options available for the builder. They are
 segmented below into two categories: required and optional parameters. Within
 each category, the available configuration keys are alphabetized.
 
-Required:
+### Required:
 
 * `access_key` (string) - The access key used to communicate with AWS.
-  If not specified, Packer will attempt to read this from environmental
-  variables `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` (in that order).
+  If not specified, Packer will use the environment variables
+  `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` (in that order), if set.
 
 * `ami_name` (string) - The name of the resulting AMI that will appear
   when managing AMIs in the AWS console or via APIs. This must be unique.
@@ -47,8 +49,8 @@ Required:
   to launch the EC2 instance to create the AMI.
 
 * `secret_key` (string) - The secret key used to communicate with AWS.
-  If not specified, Packer will attempt to read this from environmental
-  variables `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` (in that order).
+  If not specified, Packer will use the environment variables
+  `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` (in that order), if set.
 
 * `source_ami` (string) - The initial AMI used as a base for the newly
   created machine.
@@ -56,37 +58,44 @@ Required:
 * `ssh_username` (string) - The username to use in order to communicate
   over SSH to the running machine.
 
-Optional:
+### Optional:
 
 * `ami_block_device_mappings` (array of block device mappings) - Add the block
   device mappings to the AMI. The block device mappings allow for keys:
   "device\_name" (string), "virtual\_name" (string), "snapshot\_id" (string),
-  "volume\_type" (string), "volume\_size" (int), "delete\_on\_termination"
-  (bool), "no\_device" (bool), and "iops" (int).
-
-* `ami_virtualization_type` (string) - The type of virtualization for the AMI
-  you are building. This option is required to register HVM images. Can be
-  "paravirtual" (default) or "hvm".
+  "volume\_type" (string), "volume\_size" (integer), "delete\_on\_termination"
+  (boolean), "encrypted" (boolean), "no\_device" (boolean), and "iops"
+  (integer).
 
 * `ami_description` (string) - The description to set for the resulting
   AMI(s). By default this description is empty.
 
-* `ami_groups` (array of string) - A list of groups that have access
+* `ami_groups` (array of strings) - A list of groups that have access
   to launch the resulting AMI(s). By default no groups have permission
   to launch the AMI. `all` will make the AMI publicly accessible.
 
-* `ami_product_codes` (array of string) - A list of product codes to
+* `ami_product_codes` (array of strings) - A list of product codes to
   associate with the AMI. By default no product codes are associated with
   the AMI.
 
-* `ami_regions` (array of string) - A list of regions to copy the AMI to.
+* `ami_regions` (array of strings) - A list of regions to copy the AMI to.
   Tags and attributes are copied along with the AMI. AMI copying takes time
   depending on the size of the AMI, but will generally take many minutes.
 
-* `ami_users` (array of string) - A list of account IDs that have access
+* `ami_users` (array of strings) - A list of account IDs that have access
   to launch the resulting AMI(s). By default no additional users other than the user
   creating the AMI has permissions to launch it.
 
+* `associate_public_ip_address` (boolean) - If using a non-default VPC, public
+  IP addresses are not provided by default. If this is toggled, your new
+  instance will get a Public IP.
+
+* `availability_zone` (string) - Destination availability zone to launch instance in.
+  Leave this empty to allow Amazon to auto-assign.
+
+* `enhanced_networking` (boolean) - Enable enhanced networking (SriovNetSupport) on
+  HVM-compatible AMIs.
+
 * `iam_instance_profile` (string) - The name of an
   [IAM instance profile](http://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html)
   to launch the EC2 instance with.
@@ -105,15 +114,30 @@ Optional:
   access. Note that if this is specified, you must be sure the security
   group allows access to the `ssh_port` given below.
 
-* `security_group_ids` (array of string) - A list of security groups as
+* `security_group_ids` (array of strings) - A list of security groups as
   described above. Note that if this is specified, you must omit the
-  security_group_id.
+  `security_group_id`.
 
-* `ssh_port` (int) - The port that SSH will be available on. This defaults
+* `spot_price` (string) - The maximum hourly price to launch a spot instance
+  to create the AMI. It is a type of instances that EC2 starts when the maximum
+  price that you specify exceeds the current spot price. Spot price will be
+  updated based on available spot instance capacity and current spot Instance
+  requests. It may save you some costs. You can set this to "auto" for
+  Packer to automatically discover the best spot price.
+
+* `spot_price_auto_product` (string) - Required if `spot_price` is set to
+  "auto". This tells Packer what sort of AMI you're launching to find the best
+   spot price. This must be one of: `Linux/UNIX`, `SUSE Linux`, `Windows`,
+   `Linux/UNIX (Amazon VPC)`, `SUSE Linux (Amazon VPC)`, `Windows (Amazon VPC)`
+
+* `ssh_port` (integer) - The port that SSH will be available on. This defaults
   to port 22.
 
-* `ssh_private_key_file` - Use this ssh private key file instead of a generated
-  ssh key pair for connecting to the instance.
+* `ssh_private_key_file` (string) - Use this ssh private key file instead of
+  a generated ssh key pair for connecting to the instance.
+
+* `ssh_private_ip` (bool) - If true, then SSH will always use the private
+  IP if available.
 
 * `ssh_timeout` (string) - The time to wait for SSH to become available
   before timing out. The format of this value is a duration such as "5s"
@@ -122,12 +146,16 @@ Optional:
 * `subnet_id` (string) - If using VPC, the ID of the subnet, such as
   "subnet-12345def", where Packer will launch the EC2 instance.
 
-* `associate_public_ip_address` (bool) - If using a non-default VPC, public
-  IP addresses are not provided by default. If this is toggled, your new
-	instance will get a Public IP.
-
 * `tags` (object of key/value strings) - Tags applied to the AMI.
 
+* `temporary_key_pair_name` (string) - The name of the temporary keypair
+  to generate. By default, Packer generates a name with a UUID.
+
+* `token` (string) - The access token to use. This is different from
+  the access key and secret key. If you're not sure what this is, then you
+  probably don't need it. This will also be read from the `AWS_SECURITY_TOKEN`
+  environmental variable.
+
 * `user_data` (string) - User data to apply when launching the instance.
   Note that you need to be careful about escaping characters due to the
   templates being JSON. It is often more convenient to use `user_data_file`,
@@ -139,14 +167,11 @@ Optional:
 * `vpc_id` (string) - If launching into a VPC subnet, Packer needs the
   VPC ID in order to create a temporary security group within the VPC.
 
-* `availability_zone` (string) - Destination availability zone to launch instance in.
-  Leave this empty to allow Amazon to auto-assign.
-
 ## Basic Example
 
 Here is a basic example. It is completely valid except for the access keys:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "amazon-ebs",
   "access_key": "YOUR KEY HERE",
@@ -157,14 +182,12 @@ Here is a basic example. It is completely valid except for the access keys:
   "ssh_username": "ubuntu",
   "ami_name": "packer-quick-start {{timestamp}}"
 }
-</pre>
+```
 
-<div class="alert alert-block alert-info">
-<strong>Note:</strong> Packer can also read the access key and secret
+-> **Note:** Packer can also read the access key and secret
 access key from environmental variables. See the configuration reference in
 the section above for more information on what environmental variables Packer
 will look for.
-</div>
 
 ## Accessing the Instance to Debug
 
@@ -179,7 +202,7 @@ running.
 Here is an example using the optional AMI block device mappings. This will add
 the /dev/sdb and /dev/sdc block device mappings to the finished AMI.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "amazon-ebs",
   "access_key": "YOUR KEY HERE",
@@ -190,24 +213,24 @@ the /dev/sdb and /dev/sdc block device mappings to the finished AMI.
   "ssh_username": "ubuntu",
   "ami_name": "packer-quick-start {{timestamp}}",
   "ami_block_device_mappings": [
-      {
-          "device_name": "/dev/sdb",
-          "virtual_name": "ephemeral0"
-      },
-      {
-          "device_name": "/dev/sdc",
-          "virtual_name": "ephemeral1"
-      }
+    {
+      "device_name": "/dev/sdb",
+      "virtual_name": "ephemeral0"
+    },
+    {
+      "device_name": "/dev/sdc",
+      "virtual_name": "ephemeral1"
+    }
   ]
 }
-</pre>
+```
 
 ## Tag Example
 
 Here is an example using the optional AMI tags. This will add the tags
 "OS_Version" and "Release" to the finished AMI.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "amazon-ebs",
   "access_key": "YOUR KEY HERE",
@@ -222,4 +245,4 @@ Here is an example using the optional AMI tags. This will add the tags
     "Release": "Latest"
   }
 }
-</pre>
+```
diff --git a/website/source/docs/builders/amazon-instance.html.markdown b/website/source/docs/builders/amazon-instance.html.markdown
index bd5a8369e..6defb57b3 100644
--- a/website/source/docs/builders/amazon-instance.html.markdown
+++ b/website/source/docs/builders/amazon-instance.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Amazon AMI Builder (instance-store)"
+description: |-
+  The `amazon-instance` Packer builder is able to create Amazon AMIs backed by instance storage as the root device. For more information on the difference between instance storage and EBS-backed instances, see the storage for the root device section in the EC2 documentation.
 ---
 
 # AMI Builder (instance-store)
 
 Type: `amazon-instance`
 
-The `amazon-instance` builder is able to create Amazon AMIs backed by
+The `amazon-instance` Packer builder is able to create Amazon AMIs backed by
 instance storage as the root device. For more information on the difference
 between instance storage and EBS-backed instances, see the
 ["storage for the root device" section in the EC2 documentation](http://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ComponentsAMIs.html#storage-for-the-root-device).
@@ -23,12 +25,10 @@ quite a bit.
 The builder does _not_ manage AMIs. Once it creates an AMI and stores it
 in your account, it is up to you to use, delete, etc. the AMI.
 
-<div class="alert alert-block alert-info">
-<strong>Note:</strong> This builder requires that the
-<a href="http://aws.amazon.com/developertools/368">Amazon EC2 AMI Tools</a>
+-> **Note** This builder requires that the
+[Amazon EC2 AMI Tools](http://aws.amazon.com/developertools/368)
 are installed onto the machine. This can be done within a provisioner, but
 must be done before the builder finishes running.
-</div>
 
 ## Configuration Reference
 
@@ -36,11 +36,11 @@ There are many configuration options available for the builder. They are
 segmented below into two categories: required and optional parameters. Within
 each category, the available configuration keys are alphabetized.
 
-Required:
+### Required:
 
 * `access_key` (string) - The access key used to communicate with AWS.
-  If not specified, Packer will attempt to read this from environmental
-  variables `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` (in that order).
+  If not specified, Packer will use the environment variables
+  `AWS_ACCESS_KEY_ID` or `AWS_ACCESS_KEY` (in that order), if set.
 
 * `account_id` (string) - Your AWS account ID. This is required for bundling
   the AMI. This is _not the same_ as the access key. You can find your
@@ -61,8 +61,8 @@ Required:
   This bucket will be created if it doesn't exist.
 
 * `secret_key` (string) - The secret key used to communicate with AWS.
-  If not specified, Packer will attempt to read this from environmental
-  variables `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` (in that order).
+  If not specified, Packer will use the environment variables
+  `AWS_SECRET_ACCESS_KEY` or `AWS_SECRET_KEY` (in that order), if set.
 
 * `source_ami` (string) - The initial AMI used as a base for the newly
   created machine.
@@ -78,37 +78,44 @@ Required:
 * `x509_key_path` (string) - The local path to the private key for the X509
   certificate specified by `x509_cert_path`. This is used for bundling the AMI.
 
-Optional:
+### Optional:
 
 * `ami_block_device_mappings` (array of block device mappings) - Add the block
   device mappings to the AMI. The block device mappings allow for keys:
   "device\_name" (string), "virtual\_name" (string), "snapshot\_id" (string),
-  "volume\_type" (string), "volume\_size" (int), "delete\_on\_termination"
-  (bool), "no\_device" (bool), and "iops" (int).
+  "volume\_type" (string), "volume\_size" (integer), "delete\_on\_termination"
+  (boolean), "encrypted" (boolean), "no\_device" (boolean), and "iops" (integer).
   See [amazon-ebs](/docs/builders/amazon-ebs.html) for an example template.
 
+* `ami_description` (string) - The description to set for the resulting
+  AMI(s). By default this description is empty.
+
+* `ami_groups` (array of strings) - A list of groups that have access
+  to launch the resulting AMI(s). By default no groups have permission
+  to launch the AMI. `all` will make the AMI publicly accessible.
+
+* `ami_product_codes` (array of strings) - A list of product codes to
+  associate with the AMI. By default no product codes are associated with
+  the AMI.
+
+* `ami_regions` (array of strings) - A list of regions to copy the AMI to.
+  Tags and attributes are copied along with the AMI. AMI copying takes time
+  depending on the size of the AMI, but will generally take many minutes.
+
+* `ami_users` (array of strings) - A list of account IDs that have access
+  to launch the resulting AMI(s). By default no additional users other than the user
+  creating the AMI has permissions to launch it.
+
 * `ami_virtualization_type` (string) - The type of virtualization for the AMI
   you are building. This option is required to register HVM images. Can be
   "paravirtual" (default) or "hvm".
 
-* `ami_description` (string) - The description to set for the resulting
-  AMI(s). By default this description is empty.
+* `associate_public_ip_address` (boolean) - If using a non-default VPC, public
+  IP addresses are not provided by default. If this is toggled, your new
+	instance will get a Public IP.
 
-* `ami_groups` (array of string) - A list of groups that have access
-  to launch the resulting AMI(s). By default no groups have permission
-  to launch the AMI. `all` will make the AMI publicly accessible.
-
-* `ami_product_codes` (array of string) - A list of product codes to
-  associate with the AMI. By default no product codes are associated with
-  the AMI.
-
-* `ami_regions` (array of string) - A list of regions to copy the AMI to.
-  Tags and attributes are copied along with the AMI. AMI copying takes time
-  depending on the size of the AMI, but will generally take many minutes.
-
-* `ami_users` (array of string) - A list of account IDs that have access
-  to launch the resulting AMI(s). By default no additional users other than the user
-  creating the AMI has permissions to launch it.
+* `availability_zone` (string) - Destination availability zone to launch instance in.
+  Leave this empty to allow Amazon to auto-assign.
 
 * `bundle_destination` (string) - The directory on the running instance
   where the bundled AMI will be saved prior to uploading. By default this is
@@ -126,6 +133,9 @@ Optional:
 * `bundle_vol_command` (string) - The command to use to bundle the volume.
   See the "custom bundle commands" section below for more information.
 
+* `enhanced_networking` (boolean) - Enable enhanced networking (SriovNetSupport) on
+  HVM-compatible AMIs.
+
 * `iam_instance_profile` (string) - The name of an
   [IAM instance profile](http://docs.aws.amazon.com/IAM/latest/UserGuide/instance-profiles.html)
   to launch the EC2 instance with.
@@ -144,15 +154,30 @@ Optional:
   access. Note that if this is specified, you must be sure the security
   group allows access to the `ssh_port` given below.
 
-* `security_group_ids` (array of string) - A list of security groups as
+* `security_group_ids` (array of strings) - A list of security groups as
   described above. Note that if this is specified, you must omit the
-  security_group_id.
+  `security_group_id`.
 
-* `ssh_port` (int) - The port that SSH will be available on. This defaults
+* `spot_price` (string) - The maximum hourly price to launch a spot instance
+  to create the AMI. It is a type of instances that EC2 starts when the maximum
+  price that you specify exceeds the current spot price. Spot price will be
+  updated based on available spot instance capacity and current spot Instance
+  requests. It may save you some costs. You can set this to "auto" for
+  Packer to automatically discover the best spot price.
+
+* `spot_price_auto_product` (string) - Required if `spot_price` is set to
+  "auto". This tells Packer what sort of AMI you're launching to find the best
+   spot price. This must be one of: `Linux/UNIX`, `SUSE Linux`, `Windows`,
+   `Linux/UNIX (Amazon VPC)`, `SUSE Linux (Amazon VPC)`, `Windows (Amazon VPC)`
+
+* `ssh_port` (integer) - The port that SSH will be available on. This defaults
   to port 22.
 
-* `ssh_private_key_file` - Use this ssh private key file instead of a generated
-  ssh key pair for connecting to the instance.
+* `ssh_private_key_file` (string) - Use this ssh private key file instead of
+  a generated ssh key pair for connecting to the instance.
+
+* `ssh_private_ip` (bool) - If true, then SSH will always use the private
+  IP if available.
 
 * `ssh_timeout` (string) - The time to wait for SSH to become available
   before timing out. The format of this value is a duration such as "5s"
@@ -161,12 +186,11 @@ Optional:
 * `subnet_id` (string) - If using VPC, the ID of the subnet, such as
   "subnet-12345def", where Packer will launch the EC2 instance.
 
-* `associate_public_ip_address` (bool) - If using a non-default VPC, public
-  IP addresses are not provided by default. If this is toggled, your new
-	instance will get a Public IP.
-
 * `tags` (object of key/value strings) - Tags applied to the AMI.
 
+* `temporary_key_pair_name` (string) - The name of the temporary keypair
+  to generate. By default, Packer generates a name with a UUID.
+
 * `user_data` (string) - User data to apply when launching the instance.
   Note that you need to be careful about escaping characters due to the
   templates being JSON. It is often more convenient to use `user_data_file`,
@@ -188,7 +212,7 @@ Optional:
 
 Here is a basic example. It is completely valid except for the access keys:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "amazon-instance",
   "access_key": "YOUR KEY HERE",
@@ -206,14 +230,12 @@ Here is a basic example. It is completely valid except for the access keys:
 
   "ami_name": "packer-quick-start {{timestamp}}"
 }
-</pre>
+```
 
-<div class="alert alert-block alert-info">
-<strong>Note:</strong> Packer can also read the access key and secret
+-> **Note:** Packer can also read the access key and secret
 access key from environmental variables. See the configuration reference in
 the section above for more information on what environmental variables Packer
 will look for.
-</div>
 
 ## Accessing the Instance to Debug
 
@@ -247,7 +269,7 @@ across multiple lines for convenience of reading. The bundle volume command
 is responsible for executing `ec2-bundle-vol` in order to store and image
 of the root filesystem to use to create the AMI.
 
-```
+```text
 sudo -n ec2-bundle-vol \
 	-k {{.KeyPath}}  \
 	-u {{.AccountId}} \
@@ -256,19 +278,17 @@ sudo -n ec2-bundle-vol \
 	-e {{.PrivatePath}}/* \
 	-d {{.Destination}} \
 	-p {{.Prefix}} \
-	--batch
+	--batch \
+	--no-filter
 ```
 
 The available template variables should be self-explanatory based on the
 parameters they're used to satisfy the `ec2-bundle-vol` command.
 
-<div class="alert alert-block">
-  <strong>Warning!</strong> Some versions of ec2-bundle-vol silently
-ignore all .pem and .gpg files during the bundling of the AMI, which can
-cause problems on some systems, such as Ubuntu. You may want to
-customize the bundle volume command to include those files (see the
-<code>--no-filter</code> option of ec2-bundle-vol).
-</div>
+~> **Warning!** Some versions of ec2-bundle-vol silently ignore all .pem and
+.gpg files during the bundling of the AMI, which can cause problems on some
+systems, such as Ubuntu. You may want to customize the bundle volume command
+to include those files (see the `--no-filter` option of ec2-bundle-vol).
 
 ### Bundle Upload Command
 
@@ -276,7 +296,7 @@ The default value for `bundle_upload_command` is shown below. It is split
 across multiple lines for convenience of reading. The bundle upload command
 is responsible for taking the bundled volume and uploading it to S3.
 
-```
+```text
 sudo -n ec2-upload-bundle \
 	-b {{.BucketName}} \
 	-m {{.ManifestPath}} \
@@ -284,7 +304,7 @@ sudo -n ec2-upload-bundle \
 	-s {{.SecretKey}} \
 	-d {{.BundleDirectory}} \
 	--batch \
-	--url {{.S3Endpoint}} \
+	--region {{.Region}} \
 	--retry
 ```
 
diff --git a/website/source/docs/builders/amazon.html.markdown b/website/source/docs/builders/amazon.html.markdown
index e4e15f886..49d6e202e 100644
--- a/website/source/docs/builders/amazon.html.markdown
+++ b/website/source/docs/builders/amazon.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "Amazon AMI Builder"
+description: |-
+  Packer is able to create Amazon AMIs. To achieve this, Packer comes with multiple builders depending on the strategy you want to use to build the AMI.
 ---
 
 # Amazon AMI Builder
@@ -10,7 +12,7 @@ multiple builders depending on the strategy you want to use to build the
 AMI. Packer supports the following builders at the moment:
 
 * [amazon-ebs](/docs/builders/amazon-ebs.html) - Create EBS-backed AMIs
-  by launching a source instance and re-packaging it into a new AMI after
+  by launching a source AMI and re-packaging it into a new AMI after
   provisioning. If in doubt, use this builder, which is the easiest to get
   started with.
 
@@ -25,11 +27,9 @@ AMI. Packer supports the following builders at the moment:
   newcomers**. However, it is also the fastest way to build an EBS-backed
   AMI since no new EC2 instance needs to be launched.
 
-<div class="alert alert-block alert-info">
-<strong>Don't know which builder to use?</strong> If in doubt, use the
-<a href="/docs/builders/amazon-ebs.html">amazon-ebs builder</a>. It is
+-> **Don't know which builder to use?** If in doubt, use the
+[amazon-ebs builder](/docs/builders/amazon-ebs.html). It is
 much easier to use and Amazon generally recommends EBS-backed images nowadays.
-</div>
 
 ## Using an IAM Instance Profile
 
@@ -38,7 +38,7 @@ Packer will use credentials provided by the instance's IAM profile, if it has on
 
 The following policy document provides the minimal set permissions necessary for Packer to work:
 
-<pre class="prettyprint">
+```javascript
 {
   "Statement": [{
       "Effect": "Allow",
@@ -46,24 +46,27 @@ The following policy document provides the minimal set permissions necessary for
         "ec2:AttachVolume",
         "ec2:CreateVolume",
         "ec2:DeleteVolume",
+        "ec2:CreateKeypair",
+        "ec2:DeleteKeypair",
+        "ec2:CreateSecurityGroup",
+        "ec2:DeleteSecurityGroup",
+        "ec2:AuthorizeSecurityGroupIngress",
+        "ec2:CreateImage",
+        "ec2:RunInstances",
+        "ec2:TerminateInstances",
+        "ec2:StopInstances",
         "ec2:DescribeVolumes",
         "ec2:DetachVolume",
-
         "ec2:DescribeInstances",
-
         "ec2:CreateSnapshot",
         "ec2:DeleteSnapshot",
         "ec2:DescribeSnapshots",
-
         "ec2:DescribeImages",
         "ec2:RegisterImage",
-
-        "ec2:CreateTags"
+        "ec2:CreateTags",
+        "ec2:ModifyImageAttribute"
       ],
       "Resource" : "*"
   }]
 }
-</pre>
-
-Depending on what setting you use the following Actions might have to be allowed as well:
-* `ec2:ModifyImageAttribute` when using `ami_description`
+```
diff --git a/website/source/docs/builders/custom.html.markdown b/website/source/docs/builders/custom.html.markdown
index 9898d057b..a737c1bd1 100644
--- a/website/source/docs/builders/custom.html.markdown
+++ b/website/source/docs/builders/custom.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Custom Builder"
+description: |-
+  Packer is extensible, allowing you to write new builders without having to modify the core source code of Packer itself. Documentation for creating new builders is covered in the custom builders page of the Packer plugin section.
 ---
 
 # Custom Builder
diff --git a/website/source/docs/builders/digitalocean.html.markdown b/website/source/docs/builders/digitalocean.html.markdown
index e5139db27..fd92b9e51 100644
--- a/website/source/docs/builders/digitalocean.html.markdown
+++ b/website/source/docs/builders/digitalocean.html.markdown
@@ -1,12 +1,15 @@
 ---
 layout: "docs"
+page_title: "DigitalOcean Builder"
+description: |-
+  The `digitalocean` Packer builder is able to create new images for use with DigitalOcean. The builder takes a source image, runs any provisioning necessary on the image after launching it, then snapshots it into a reusable image. This reusable image can then be used as the foundation of new servers that are launched within DigitalOcean.
 ---
 
 # DigitalOcean Builder
 
 Type: `digitalocean`
 
-The `digitalocean` builder is able to create new images for use with
+The `digitalocean` Packer builder is able to create new images for use with
 [DigitalOcean](http://www.digitalocean.com). The builder takes a source
 image, runs any provisioning necessary on the image after launching it,
 then snapshots it into a reusable image. This reusable image can then be
@@ -21,43 +24,68 @@ There are many configuration options available for the builder. They are
 segmented below into two categories: required and optional parameters. Within
 each category, the available configuration keys are alphabetized.
 
-Required:
+### Required v1 api:
 
 * `api_key` (string) - The API key to use to access your account. You can
   retrieve this on the "API" page visible after logging into your account
-  on DigitalOcean. Alternatively, the builder looks for the environment
-  variable `DIGITALOCEAN_API_KEY`.
+  on DigitalOcean.
+  If not specified, Packer will use the environment variable
+  `DIGITALOCEAN_API_KEY`, if set.
 
 * `client_id` (string) - The client ID to use to access your account. You can
   find this on the "API" page visible after logging into your account on
-  DigitalOcean. Alternatively, the builder looks for the environment
-  variable `DIGITALOCEAN_CLIENT_ID`.
+  DigitalOcean.
+  If not specified, Packer will use the environment variable
+  `DIGITALOCEAN_CLIENT_ID`, if set.
 
-Optional:
+### Required v2 api:
 
-* `image_id` (int) - The ID of the base image to use. This is the image that
-  will be used to launch a new droplet and provision it. Defaults to "3101045",
-  which happens to be "Ubuntu 12.04.4 x64".
+* `api_token` (string) - The client TOKEN to use to access your account. If it
+  specified, then use v2 api (current), if not then used old (v1) deprecated api.
+  Also it can be specified via environment variable `DIGITALOCEAN_API_TOKEN`, if set.
 
-* `region_id` (int) - The ID of the region to launch the droplet in. Consequently,
-  this is the region where the snapshot will be available. This defaults to
-  "1", which is "New York 1".
+### Optional:
 
-* `size_id` (int) - The ID of the droplet size to use. This defaults to "66",
-  which is the 512MB droplet.
+* `api_url` (string) - API endpoint, by default use https://api.digitalocean.com
+  Also it can be specified via environment variable `DIGITALOCEAN_API_URL`, if set.
 
-* `private_networking` (bool) - Set to `true` to enable private networking
+* `droplet_name` (string) - The name assigned to the droplet. DigitalOcean
+  sets the hostname of the machine to this value.
+
+* `image` (string) - The name (or slug) of the base image to use. This is the
+  image that will be used to launch a new droplet and provision it. This
+  defaults to 'ubuntu-12-04-x64' which is the slug for "Ubuntu 12.04.4 x64".
+  See https://developers.digitalocean.com/#list-all-images for details on how to get a list of the the accepted image names/slugs.
+
+* `image_id` (integer) - The ID of the base image to use. This is the image that
+  will be used to launch a new droplet and provision it.
+  This setting is deprecated. Use `image` instead.
+
+* `private_networking` (boolean) - Set to `true` to enable private networking
   for the droplet being created. This defaults to `false`, or not enabled.
 
+* `region` (string) - The name (or slug) of the region to launch the droplet in.
+  Consequently, this is the region where the snapshot will be available.
+  This defaults to "nyc1", which is the slug for "New York 1".
+  See https://developers.digitalocean.com/regions/ for the accepted region names/slugs.
+
+* `region_id` (integer) - The ID of the region to launch the droplet in. Consequently,
+  this is the region where the snapshot will be available.
+  This setting is deprecated. Use `region` instead.
+
+* `size` (string) - The name (or slug) of the droplet size to use.
+  This defaults to "512mb", which is the slug for "512MB".
+  See https://developers.digitalocean.com/sizes/ for the accepted size names/slugs.
+
+* `size_id` (integer) - The ID of the droplet size to use.
+  This setting is deprecated. Use `size` instead.
+
 * `snapshot_name` (string) - The name of the resulting snapshot that will
   appear in your account. This must be unique.
   To help make this unique, use a function like `timestamp` (see
   [configuration templates](/docs/templates/configuration-templates.html) for more info)
 
-* `droplet_name` (string) - The name assigned to the droplet. DigitalOcean
-  sets the hostname of the machine to this value.
-
-* `ssh_port` (int) - The port that SSH will be available on. Defaults to port
+* `ssh_port` (integer) - The port that SSH will be available on. Defaults to port
   22.
 
 * `ssh_timeout` (string) - The time to wait for SSH to become available
@@ -68,21 +96,21 @@ Optional:
   over SSH to the running droplet. Default is "root".
 
 * `state_timeout` (string) - The time to wait, as a duration string,
-for a droplet to enter a desired state (such as "active") before
-timing out. The default state timeout is "6m".
+  for a droplet to enter a desired state (such as "active") before
+  timing out. The default state timeout is "6m".
 
 ## Basic Example
 
 Here is a basic example. It is completely valid as soon as you enter your
 own access tokens:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "digitalocean",
   "client_id": "YOUR CLIENT ID",
   "api_key": "YOUR API KEY"
 }
-</pre>
+```
 
 ## Finding Image, Region, and Size IDs
 
diff --git a/website/source/docs/builders/docker.html.markdown b/website/source/docs/builders/docker.html.markdown
index 315d5ff63..78ca90a56 100644
--- a/website/source/docs/builders/docker.html.markdown
+++ b/website/source/docs/builders/docker.html.markdown
@@ -1,23 +1,26 @@
 ---
 layout: "docs"
+page_title: "Docker Builder"
+description: |-
+  The `docker` Packer builder builds Docker images using Docker. The builder starts a Docker container, runs provisioners within this container, then exports the container for reuse or commits the image.
 ---
 
 # Docker Builder
 
 Type: `docker`
 
-The Docker builder builds [Docker](http://www.docker.io) images using
+The `docker` Packer builder builds [Docker](http://www.docker.io) images using
 Docker. The builder starts a Docker container, runs provisioners within
-this container, then exports the container for re-use.
+this container, then exports the container for reuse or commits the image.
 
 Packer builds Docker containers _without_ the use of
-[Dockerfiles](http://docs.docker.io/en/latest/use/builder/).
+[Dockerfiles](https://docs.docker.com/reference/builder/).
 By not using Dockerfiles, Packer is able to provision
 containers with portable scripts or configuration management systems
 that are not tied to Docker in any way. It also has a simpler mental model:
 you provision containers much the same way you provision a normal virtualized
 or dedicated server. For more information, read the section on
-[Dockerfiles](#toc_4).
+[Dockerfiles](#toc_8).
 
 The Docker builder must run on a machine that has Docker installed. Therefore
 the builder only works on machines that support Docker (modern Linux machines).
@@ -25,18 +28,33 @@ If you want to use Packer to build Docker containers on another platform,
 use [Vagrant](http://www.vagrantup.com) to start a Linux environment, then
 run Packer within that environment.
 
-## Basic Example
+## Basic Example: Export
 
 Below is a fully functioning example. It doesn't do anything useful, since
 no provisioners are defined, but it will effectively repackage an image.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "docker",
   "image": "ubuntu",
   "export_path": "image.tar"
 }
-</pre>
+```
+
+## Basic Example: Commit
+
+Below is another example, the same as above but instead of exporting the
+running container, this one commits the container to an image. The image
+can then be more easily tagged, pushed, etc.
+
+```javascript
+{
+  "type": "docker",
+  "image": "ubuntu",
+  "commit": true
+}
+```
+
 
 ## Configuration Reference
 
@@ -44,39 +62,62 @@ Configuration options are organized below into two categories: required and
 optional. Within each category, the available options are alphabetized and
 described.
 
-Required:
+### Required:
+
+* `commit` (boolean) - If true, the container will be committed to an
+  image rather than exported. This cannot be set if `export_path` is set.
 
 * `export_path` (string) - The path where the final container will be exported
-  as a tar file.
+  as a tar file. This cannot be set if `commit` is set to true.
 
 * `image` (string) - The base image for the Docker container that will
   be started. This image will be pulled from the Docker registry if it
   doesn't already exist.
 
-Optional:
+### Optional:
 
-* `pull` (bool) - If true, the configured image will be pulled using
+* `login` (boolean) - Defaults to false. If true, the builder will
+    login in order to pull the image. The builder only logs in for the
+    duration of the pull. It always logs out afterwards.
+
+* `login_email` (string) - The email to use to authenticate to login.
+
+* `login_username` (string) - The username to use to authenticate to login.
+
+* `login_password` (string) - The password to use to authenticate to login.
+
+* `login_server` (string) - The server address to login to.
+
+* `pull` (boolean) - If true, the configured image will be pulled using
   `docker pull` prior to use. Otherwise, it is assumed the image already
   exists and can be used. This defaults to true if not set.
 
 * `run_command` (array of strings) - An array of arguments to pass to
-  `docker` in order to run the container. By default this is set to
-  `["run", "-d", "-i", "-t", "-v", "{{.Volumes}}", "{{.Image}}", "/bin/bash"]`.
+  `docker run` in order to run the container. By default this is set to
+  `["-d", "-i", "-t", "{{.Image}}", "/bin/bash"]`.
   As you can see, you have a couple template variables to customize, as well.
 
-## Using the Artifact
+* `volumes` (map of strings to strings) - A mapping of additional volumes
+   to mount into this container. The key of the object is the host path,
+   the value is the container path.
+
+## Using the Artifact: Export
 
 Once the tar artifact has been generated, you will likely want to import, tag,
 and push it to a container repository. Packer can do this for you automatically
 with the [docker-import](/docs/post-processors/docker-import.html) and
 [docker-push](/docs/post-processors/docker-push.html) post-processors.
 
+**Note:** This section is covering how to use an artifact that has been
+_exported_. More specifically, if you set `export_path` in your configuration.
+If you set `commit`, see the next section.
+
 The example below shows a full configuration that would import and push
 the created image:
 
-<pre class="prettyprint">
+```javascript
 {
-    "post-processors": [
+  "post-processors": [
 		[
 			{
 				"type": "docker-import",
@@ -87,21 +128,44 @@ the created image:
 		]
 	]
 }
-</pre>
+```
 
 If you want to do this manually, however, perhaps from a script, you can
 import the image using the process below:
 
-    docker import - registry.mydomain.com/mycontainer:latest < artifact.tar
+```text
+$ docker import - registry.mydomain.com/mycontainer:latest < artifact.tar
+```
 
 You can then add additional tags and push the image as usual with `docker tag`
 and `docker push`, respectively.
 
+## Using the Artifact: Committed
+
+If you committed your container to an image, you probably want to tag,
+save, push, etc. Packer can do this automatically for you. An example is
+shown below which tags and pushes the image:
+
+```javascript
+{
+  "post-processors": [
+		[
+			{
+				"type": "docker-tag",
+				"repository": "mitchellh/packer",
+				"tag": "0.7"
+			},
+			"docker-push"
+		]
+	]
+}
+```
+
 ## Dockerfiles
 
 This builder allows you to build Docker images _without_ Dockerfiles.
 
-With this builder, you can repeatably create Docker images without the use
+With this builder, you can repeatably create Docker images without the use of
 a Dockerfile. You don't need to know the syntax or semantics of Dockerfiles.
 Instead, you can just provide shell scripts, Chef recipes, Puppet manifests,
 etc. to provision your Docker container just like you would a regular
diff --git a/website/source/docs/builders/googlecompute.markdown b/website/source/docs/builders/googlecompute.markdown
index bab2ffce3..56d568ac0 100644
--- a/website/source/docs/builders/googlecompute.markdown
+++ b/website/source/docs/builders/googlecompute.markdown
@@ -1,84 +1,95 @@
 ---
 layout: "docs"
+page_title: "Google Compute Builder"
+description: |-
+  The `googlecompute` Packer builder is able to create images for use with Google Compute Engine (GCE) based on existing images. Google Compute Engine doesn't allow the creation of images from scratch.
 ---
 
 # Google Compute Builder
 
 Type: `googlecompute`
 
-The `googlecompute` builder is able to create
-[images](https://developers.google.com/compute/docs/images)
-for use with [Google Compute Engine](https://cloud.google.com/products/compute-engine)
-(GCE) based on existing images. Google Compute Engine doesn't allow the creation
-of images from scratch.
+The `googlecompute` Packer builder is able to create [images](https://developers.google.com/compute/docs/images) for use with
+[Google Compute Engine](https://cloud.google.com/products/compute-engine)(GCE) based on existing images. Google
+Compute Engine doesn't allow the creation of images from scratch.
 
-## Setting Up API Access
+## Authentication
 
-There is a small setup step required in order to obtain the credentials
-that Packer needs to use Google Compute Engine. This needs to be done only
-once if you intend to share the credentials.
+Authenticating with Google Cloud services requires at most one JSON file, 
+called the _account file_. The _account file_ is **not** required if you are running
+the `googlecompute` Packer builder from a GCE instance with a properly-configured
+[Compute Engine Service Account](https://cloud.google.com/compute/docs/authentication.
 
-In order for Packer to talk to Google Compute Engine, it will need
-a _client secrets_ JSON file and a _client private key_. Both of these are
-obtained from the [Google Cloud Console](https://cloud.google.com/console).
+### Running With a Compute Engine Service Account
+If you run the `googlecompute` Packer builder from a GCE instance, you can configure that
+instance to use a [Compute Engine Service Account](https://cloud.google.com/compute/docs/authentication). This will allow Packer to authenticate
+to Google Cloud without having to bake in a separate credential/authentication file. 
 
-Follow the steps below:
+To create a GCE instance that uses a service account, provide the required scopes when
+launching the intance.
 
-1. Log into the [Google Cloud Console](https://cloud.google.com/console)
-2. Click on the project you want to use Packer with (or create one if you
-   don't have one yet).
-3. Click "APIs & auth" in the left sidebar
-4. Click "Credentials" in the left sidebar
-5. Click "Create New Client ID" and choose "Service Account"
-6. A private key will be downloaded for you. Note the password for the private key! This private key is your _client private key_.
-7. After creating the account, click "Download JSON". This is your _client secrets JSON_ file. Make sure you didn't download the JSON from the "OAuth 2.0" section! This is a common mistake and will cause the builder to not work.
+For `gcloud`, do this via the `--scopes` parameter:
 
-Finally, one last step, you'll have to convert the `p12` file you
-got from Google into the PEM format. You can do this with OpenSSL, which
-is installed standard on most Unixes:
-
-```
-$ openssl pkcs12 -in <path to .p12> -nocerts -passin pass:notasecret \
-    -nodes -out private_key.pem
+```sh
+gcloud compute --project YOUR_PROJECT instances create "INSTANCE-NAME" ... \
+               --scopes "https://www.googleapis.com/auth/compute" \
+                        "https://www.googleapis.com/auth/devstorage.full_control" \
+               ...
 ```
 
-The client secrets JSON you downloaded along with the new "private\_key.pem"
-file are the two files you need to configure Packer with to talk to GCE.
+For the [Google Developers Console](https://console.developers.google.com):
+
+1. Choose "Show advanced options"
+2. Tick "Enable Compute Engine service account"
+3. Choose "Read Write" for Compute
+4. Chose "Full" for "Storage"
+
+**The service account will be used automatically by Packer as long as there is
+no _account file_ specified in the Packer configuration file.**
+
+### Running Without a Compute Engine Service Account
+
+The [Google Developers Console](https://console.developers.google.com) allows you to
+create and download a credential file that will let you use the `googlecompute` Packer
+builder anywhere. To make
+the process more straightforwarded, it is documented here.
+
+1. Log into the [Google Developers Console](https://console.developers.google.com)
+   and select a project.
+
+2. Under the "APIs & Auth" section, click "Credentials."
+
+3. Click the "Create new Client ID" button, select "Service account", and click "Create Client ID"
+
+4. Click "Generate new JSON key" for the Service Account you just created. A JSON file will be downloaded automatically. This is your
+   _account file_.
 
 ## Basic Example
 
 Below is a fully functioning example. It doesn't do anything useful,
 since no provisioners are defined, but it will effectively repackage an
-existing GCE image. The client secrets file and private key file are the
-files obtained in the previous section.
+existing GCE image. The account file is obtained in the previous section.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "googlecompute",
   "bucket_name": "my-project-packer-images",
-  "client_secrets_file": "client_secret.json",
-  "private_key_file": "XXXXXX-privatekey.p12",
+  "account_file": "account.json",
   "project_id": "my-project",
-  "source_image": "debian-7-wheezy-v20131014",
+  "source_image": "debian-7-wheezy-v20140718",
   "zone": "us-central1-a"
 }
-</pre>
+```
 
 ## Configuration Reference
 
 Configuration options are organized below into two categories: required and optional. Within
 each category, the available options are alphabetized and described.
 
-Required:
+### Required:
 
 * `bucket_name` (string) - The Google Cloud Storage bucket to store the
-  images that are created. The bucket must already exist in your project.
-
-* `client_secrets_file` (string) - The client secrets JSON file that
-  was set up in the section above.
-
-* `private_key_file` (string) - The client private key file that was
-  generated in the section above.
+  images that are created. The bucket must already exist in your project
 
 * `project_id` (string) - The project ID that will be used to launch instances
   and store images.
@@ -89,7 +100,14 @@ Required:
 * `zone` (string) - The zone in which to launch the instance used to create
   the image. Example: "us-central1-a"
 
-Optional:
+### Optional:
+
+* `account_file` (string) - The JSON file containing your account credentials.
+     Not required if you run Packer on a GCE instance with a service account.
+     Instructions for creating file or using service accounts are above.
+
+* `disk_size` (integer) - The size of the disk in GB.
+  This defaults to 10, which is 10GB.
 
 * `image_name` (string) - The unique name of the resulting image.
   Defaults to `packer-{{timestamp}}`.
@@ -101,13 +119,12 @@ Optional:
 
 * `machine_type` (string) - The machine type. Defaults to `n1-standard-1`.
 
+* `metadata` (object of key/value strings)
+
 * `network` (string) - The Google Compute network to use for the launched
   instance. Defaults to `default`.
 
-* `passphrase` (string) - The passphrase to use if the `private_key_file`
-  is encrypted.
-
-* `ssh_port` (int) - The SSH port. Defaults to 22.
+* `ssh_port` (integer) - The SSH port. Defaults to 22.
 
 * `ssh_timeout` (string) - The time to wait for SSH to become available.
   Defaults to "1m".
@@ -117,6 +134,8 @@ Optional:
 * `state_timeout` (string) - The time to wait for instance state changes.
   Defaults to "5m".
 
+* `tags` (array of strings)
+
 ## Gotchas
 
 Centos images have root ssh access disabled by default. Set `ssh_username` to any user, which will be created by packer with sudo access.
diff --git a/website/source/docs/builders/null.html.markdown b/website/source/docs/builders/null.html.markdown
index c1c6c1ebc..1229db359 100644
--- a/website/source/docs/builders/null.html.markdown
+++ b/website/source/docs/builders/null.html.markdown
@@ -1,12 +1,15 @@
 ---
 layout: "docs"
+page_title: "Null Builder"
+description: |-
+  The `null` Packer builder is not really a builder, it just sets up an SSH connection and runs the provisioners. It can be used to debug provisioners without incurring high wait times. It does not create any kind of image or artifact.
 ---
 
 # Null Builder
 
 Type: `null`
 
-The null builder is not really a builder, it just setups a SSH connection
+The `null` Packer builder is not really a builder, it just sets up an SSH connection
 and runs the provisioners. It can be used to debug provisioners without
 incurring high wait times. It does not create any kind of image or artifact.
 
@@ -15,22 +18,22 @@ incurring high wait times. It does not create any kind of image or artifact.
 Below is a fully functioning example. It doesn't do anything useful, since
 no provisioners are defined, but it will connect to the specified host via ssh.
 
-<pre class="prettyprint">
+```javascript
 {
   "type":     "null",
   "host":     "127.0.0.1",
-  "username": "foo",
-  "password": "bar"
+  "ssh_username": "foo",
+  "ssh_password": "bar"
 }
-</pre>
+```
 
 ## Configuration Reference
 
-Configuration options are organized below into two categories: required and
+Configuration options are organized into two categories: required and
 optional. Within each category, the available options are alphabetized and
 described.
 
-Required:
+### Required:
 
 * `host` (string) - The hostname or IP address to connect to.
 
@@ -42,7 +45,7 @@ Required:
 
 * `ssh_username` (string) - The username to be used for the ssh connection.
 
-Optional:
+### Optional:
 
-* `port` (int) - port to connect to, defaults to 22.
+* `port` (integer) - ssh port to connect to, defaults to 22.
 
diff --git a/website/source/docs/builders/openstack.html.markdown b/website/source/docs/builders/openstack.html.markdown
index db432ed41..0e864e4bd 100644
--- a/website/source/docs/builders/openstack.html.markdown
+++ b/website/source/docs/builders/openstack.html.markdown
@@ -1,12 +1,15 @@
 ---
 layout: "docs"
+page_title: "OpenStack Builder"
+description: |-
+  The `openstack` Packer builder is able to create new images for use with OpenStack. The builder takes a source image, runs any provisioning necessary on the image after launching it, then creates a new reusable image. This reusable image can then be used as the foundation of new servers that are launched within OpenStack. The builder will create temporary keypairs that provide temporary access to the server while the image is being created. This simplifies configuration quite a bit.
 ---
 
 # OpenStack Builder
 
 Type: `openstack`
 
-The `openstack` builder is able to create new images for use with
+The `openstack` Packer builder is able to create new images for use with
 [OpenStack](http://www.openstack.org). The builder takes a source
 image, runs any provisioning necessary on the image after launching it,
 then creates a new reusable image. This reusable image can then be
@@ -24,7 +27,7 @@ There are many configuration options available for the builder. They are
 segmented below into two categories: required and optional parameters. Within
 each category, the available configuration keys are alphabetized.
 
-Required:
+### Required:
 
 * `flavor` (string) - The ID or full URL for the desired flavor for the
   server to be created.
@@ -32,43 +35,68 @@ Required:
 * `image_name` (string) - The name of the resulting image.
 
 * `password` (string) - The password used to connect to the OpenStack service.
-  If not specified, Packer will attempt to read this from the
-  `SDK_PASSWORD` or `OS_PASSWORD` environment variable.
+  If not specified, Packer will use the environment variables
+  `SDK_PASSWORD` or `OS_PASSWORD` (in that order), if set.
 
 * `provider` (string) - The provider used to connect to the OpenStack service.
-  If not specified, Packer will attempt to read this from the
-  `SDK_PROVIDER` environment variable. For Rackspace this should be `rackspace-us`
-  or `rackspace-uk`.
-
-* `region` (string) - The name of the region, such as "DFW", in which
-  to launch the server to create the AMI. If not specified, Packer will
-  attempt to read this from the `SDK_REGION` or `OS_REGION_NAME` environmental
-  variables.
+  If not specified, Packer will use the environment variable
+  `SDK_PROVIDER`, if set.
+  For Rackspace this should be `rackspace-us` or `rackspace-uk`.
 
 * `source_image` (string) - The ID or full URL to the base image to use.
   This is the image that will be used to launch a new server and provision it.
 
 * `username` (string) - The username used to connect to the OpenStack service.
-  If not specified, Packer will attempt to read this from the
-  `SDK_USERNAME` or `OS_USERNAME` environment variable.
+  If not specified, Packer will use the environment variables
+  `SDK_USERNAME` or `OS_USERNAME` (in that order), if set.
 
-Optional:
+### Optional:
 
 * `api_key` (string) - The API key used to access OpenStack. Some OpenStack
-  installations require this. If not specified, Packer will attempt to
-  read this from the `SDK_API_KEY` environmental variable.
+  installations require this.
+  If not specified, Packer will use the environment variables
+  `SDK_API_KEY`, if set.
+
+* `floating_ip` (string) - A specific floating IP to assign to this instance.
+  `use_floating_ip` must also be set to true for this to have an affect.
+
+* `floating_ip_pool` (string) - The name of the floating IP pool to use
+  to allocate a floating IP. `use_floating_ip` must also be set to true
+  for this to have an affect.
+
+* `insecure` (boolean) - Whether or not the connection to OpenStack can be done
+  over an insecure connection. By default this is false.
+
+* `networks` (array of strings) - A list of networks by UUID to attach
+  to this instance.
+
+* `openstack_provider` (string)
 
 * `project` (string) - The project name to boot the instance into. Some
-  OpenStack installations require this. If not specified, Packer will attempt
-  to read this from the `SDK_PROJECT` or `OS_TENANT_NAME` environmental
-  variables.
+  OpenStack installations require this.
+  If not specified, Packer will use the environment variables
+  `SDK_PROJECT` or `OS_TENANT_NAME` (in that order), if set.
 
 * `provider` (string) - A name of a provider that has a slightly
   different API model. Currently supported values are "openstack" (default),
-  and "rackspace". If not specified, Packer will attempt to read this from
-  the `SDK_PROVIDER` or `OS_AUTH_URL` environmental variables.
+  and "rackspace".
+  If not specified, Packer will use the environment variables
+  `SDK_PROVIDER` or `OS_AUTH_URL` (in that order), if set.
 
-* `ssh_port` (int) - The port that SSH will be available on. Defaults to port
+* `proxy_url` (string)
+
+* `security_groups` (array of strings) - A list of security groups by name
+  to add to this instance.
+
+* `region` (string) - The name of the region, such as "DFW", in which
+  to launch the server to create the AMI.
+  If not specified, Packer will use the environment variables
+  `SDK_REGION` or `OS_REGION_NAME` (in that order), if set.
+  For a `provider` of "rackspace", it is required to specify a region,
+  either using this option or with an environment variable. For other
+  providers, including a private cloud, specifying a region is optional.
+
+* `ssh_port` (integer) - The port that SSH will be available on. Defaults to port
   22.
 
 * `ssh_timeout` (string) - The time to wait for SSH to become available
@@ -78,24 +106,57 @@ Optional:
 * `ssh_username` (string) - The username to use in order to communicate
   over SSH to the running server. The default is "root".
 
-## Basic Example
+* `tenant_id` (string) - Tenant ID for accessing OpenStack if your
+  installation requires this.
+
+* `use_floating_ip` (boolean) - Whether or not to use a floating IP for
+  the instance. Defaults to false.
+
+## Basic Example: Rackspace public cloud
 
 Here is a basic example. This is a working example to build a
 Ubuntu 12.04 LTS (Precise Pangolin) on Rackspace OpenStack cloud offering.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "openstack",
   "username": "",
-  "password": "",
+  "api_key": "",
+  "openstack_provider": "rackspace",
   "provider": "rackspace-us",
+  "openstack_provider":"rackspace",
   "region": "DFW",
   "ssh_username": "root",
   "image_name": "Test image",
   "source_image": "23b564c9-c3e6-49f9-bc68-86c7a9ab5018",
   "flavor": "2"
 }
-</pre>
+```
+
+## Basic Example: Private OpenStack cloud
+
+This example builds an Ubuntu 14.04 image on a private OpenStack cloud,
+powered by Metacloud.
+
+```javascript
+{
+  "type": "openstack",
+  "ssh_username": "root",
+  "image_name": "ubuntu1404_packer_test_1",
+  "source_image": "91d9c168-d1e5-49ca-a775-3bfdbb6c97f1",
+  "flavor": "2"
+}
+```
+
+In this case, the connection information for connecting to OpenStack
+doesn't appear in the template. That is because I source a standard
+OpenStack script with environment variables set before I run this. This
+script is setting environment variables like:
+
+* `OS_AUTH_URL`
+* `OS_TENANT_ID`
+* `OS_USERNAME`
+* `OS_PASSWORD`
 
 ## Troubleshooting
 
diff --git a/website/source/docs/builders/parallels-iso.html.markdown b/website/source/docs/builders/parallels-iso.html.markdown
new file mode 100644
index 000000000..3d8bbaddc
--- /dev/null
+++ b/website/source/docs/builders/parallels-iso.html.markdown
@@ -0,0 +1,302 @@
+---
+layout: "docs"
+page_title: "Parallels Builder (from an ISO)"
+description: |-
+  The Parallels Packer builder is able to create Parallels Desktop for Mac virtual machines and export them in the PVM format, starting from an ISO image.
+---
+
+# Parallels Builder (from an ISO)
+
+Type: `parallels-iso`
+
+The Parallels Packer builder is able to create
+[Parallels Desktop for Mac](http://www.parallels.com/products/desktop/) virtual
+machines and export them in the PVM format, starting from an
+ISO image.
+
+The builder builds a virtual machine by creating a new virtual machine
+from scratch, booting it, installing an OS, provisioning software within
+the OS, then shutting it down. The result of the Parallels builder is a directory
+containing all the files necessary to run the virtual machine portably.
+
+## Basic Example
+
+Here is a basic example. This example is not functional. It will start the
+OS installer but then fail because we don't provide the preseed file for
+Ubuntu to self-install. Still, the example serves to show the basic configuration:
+
+```javascript
+{
+  "type": "parallels-iso",
+  "guest_os_type": "ubuntu",
+  "iso_url": "http://releases.ubuntu.com/12.04/ubuntu-12.04.3-server-amd64.iso",
+  "iso_checksum": "2cbe868812a871242cdcdd8f2fd6feb9",
+  "iso_checksum_type": "md5",
+  "parallels_tools_flavor": "lin"
+  "ssh_username": "packer",
+  "ssh_password": "packer",
+  "ssh_wait_timeout": "30s",
+  "shutdown_command": "echo 'packer' | sudo -S shutdown -P now"
+}
+```
+
+It is important to add a `shutdown_command`. By default Packer halts the
+virtual machine and the file system may not be sync'd. Thus, changes made in a
+provisioner might not be saved.
+
+## Configuration Reference
+
+There are many configuration options available for the Parallels builder.
+They are organized below into two categories: required and optional. Within
+each category, the available options are alphabetized and described.
+
+### Required:
+
+* `iso_checksum` (string) - The checksum for the OS ISO file. Because ISO
+  files are so large, this is required and Packer will verify it prior
+  to booting a virtual machine with the ISO attached. The type of the
+  checksum is specified with `iso_checksum_type`, documented below.
+
+* `iso_checksum_type` (string) - The type of the checksum specified in
+  `iso_checksum`. Valid values are "none", "md5", "sha1", "sha256", or
+  "sha512" currently. While "none" will skip checksumming, this is not
+  recommended since ISO files are generally large and corruption does happen
+  from time to time.
+
+* `iso_url` (string) - A URL to the ISO containing the installation image.
+  This URL can be either an HTTP URL or a file URL (or path to a file).
+  If this is an HTTP URL, Packer will download it and cache it between
+  runs.
+
+* `ssh_username` (string) - The username to use to SSH into the machine
+  once the OS is installed.
+
+* `parallels_tools_flavor` (string) - The flavor of the Parallels Tools ISO to
+  install into the VM. Valid values are "win", "lin", "mac", "os2" and "other".
+  This can be ommited only if `parallels_tools_mode` is "disable".
+
+### Optional:
+
+* `boot_command` (array of strings) - This is an array of commands to type
+  when the virtual machine is first booted. The goal of these commands should
+  be to type just enough to initialize the operating system installer. Special
+  keys can be typed as well, and are covered in the section below on the boot
+  command. If this is not specified, it is assumed the installer will start
+  itself.
+
+* `boot_wait` (string) - The time to wait after booting the initial virtual
+  machine before typing the `boot_command`. The value of this should be
+  a duration. Examples are "5s" and "1m30s" which will cause Packer to wait
+  five seconds and one minute 30 seconds, respectively. If this isn't specified,
+  the default is 10 seconds.
+
+* `disk_size` (integer) - The size, in megabytes, of the hard disk to create
+  for the VM. By default, this is 40000 (about 40 GB).
+
+* `floppy_files` (array of strings) - A list of files to place onto a floppy
+  disk that is attached when the VM is booted. This is most useful
+  for unattended Windows installs, which look for an `Autounattend.xml` file
+  on removable media. By default, no floppy will be attached. All files
+  listed in this setting get placed into the root directory of the floppy
+  and the floppy is attached as the first floppy device. Currently, no
+  support exists for creating sub-directories on the floppy. Wildcard
+  characters (*, ?, and []) are allowed. Directory names are also allowed,
+  which will add all the files found in the directory to the floppy.
+
+* `guest_os_type` (string) - The guest OS type being installed. By default
+  this is "other", but you can get _dramatic_ performance improvements by
+  setting this to the proper value. To view all available values for this
+  run `prlctl create x --distribution list`. Setting the correct value hints to
+  Parallels Desktop how to optimize the virtual hardware to work best with
+  that operating system.
+
+* `hard_drive_interface` (string) - The type of controller that the
+  hard drives are attached to, defaults to "sata". Valid options are
+  "sata", "ide", and "scsi".
+
+* `host_interfaces` (array of strings) - A list of which interfaces on the
+  host should be searched for a IP address. The first IP address found on
+  one of these will be used as `{{ .HTTPIP }}` in the `boot_command`.
+  Defaults to ["en0", "en1", "en2", "en3", "en4", "en5", "en6", "en7", "en8",
+  "en9", "ppp0", "ppp1", "ppp2"].
+
+* `http_directory` (string) - Path to a directory to serve using an HTTP
+  server. The files in this directory will be available over HTTP that will
+  be requestable from the virtual machine. This is useful for hosting
+  kickstart files and so on. By default this is "", which means no HTTP
+  server will be started. The address and port of the HTTP server will be
+  available as variables in `boot_command`. This is covered in more detail
+  below.
+
+* `http_port_min` and `http_port_max` (integer) - These are the minimum and
+  maximum port to use for the HTTP server started to serve the `http_directory`.
+  Because Packer often runs in parallel, Packer will choose a randomly available
+  port in this range to run the HTTP server. If you want to force the HTTP
+  server to be on one port, make this minimum and maximum port the same.
+  By default the values are 8000 and 9000, respectively.
+
+* `iso_urls` (array of strings) - Multiple URLs for the ISO to download.
+  Packer will try these in order. If anything goes wrong attempting to download
+  or while downloading a single URL, it will move on to the next. All URLs
+  must point to the same file (same checksum). By default this is empty
+  and `iso_url` is used. Only one of `iso_url` or `iso_urls` can be specified.
+
+* `output_directory` (string) - This is the path to the directory where the
+  resulting virtual machine will be created. This may be relative or absolute.
+  If relative, the path is relative to the working directory when `packer`
+  is executed. This directory must not exist or be empty prior to running the builder.
+  By default this is "output-BUILDNAME" where "BUILDNAME" is the name
+  of the build.
+
+* `parallels_tools_guest_path` (string) - The path in the VM to upload Parallels
+  Tools. This only takes effect if `parallels_tools_mode` is not "disable".
+  This is a [configuration template](/docs/templates/configuration-templates.html)
+  that has a single valid variable: `Flavor`, which will be the value of
+  `parallels_tools_flavor`. By default the upload path is set to
+  `prl-tools-{{.Flavor}}.iso`.
+
+* `parallels_tools_mode` (string) - The method by which Parallels Tools are
+  made available to the guest for installation. Valid options are "upload",
+  "attach", or "disable". The functions of each of these should be
+  self-explanatory. The default value is "upload".
+
+* `prlctl` (array of array of strings) - Custom `prlctl` commands to execute in
+  order to further customize the virtual machine being created. The value of
+  this is an array of commands to execute. The commands are executed in the order
+  defined in the template. For each command, the command is defined itself as an
+  array of strings, where each string represents a single argument on the
+  command-line to `prlctl` (but excluding `prlctl` itself). Each arg is treated
+  as a [configuration template](/docs/templates/configuration-templates.html),
+  where the `Name` variable is replaced with the VM name. More details on how
+  to use `prlctl` are below.
+
+* `prlctl_version_file` (string) - The path within the virtual machine to upload
+  a file that contains the `prlctl` version that was used to create the machine.
+  This information can be useful for provisioning. By default this is
+  ".prlctl_version", which will generally upload it into the home directory.
+
+* `shutdown_command` (string) - The command to use to gracefully shut down
+  the machine once all the provisioning is done. By default this is an empty
+  string, which tells Packer to just forcefully shut down the machine.
+
+* `shutdown_timeout` (string) - The amount of time to wait after executing
+  the `shutdown_command` for the virtual machine to actually shut down.
+  If it doesn't shut down in this time, it is an error. By default, the timeout
+  is "5m", or five minutes.
+
+* `ssh_key_path` (string) - Path to a private key to use for authenticating
+  with SSH. By default this is not set (key-based auth won't be used).
+  The associated public key is expected to already be configured on the
+  VM being prepared by some other process (kickstart, etc.).
+
+* `ssh_password` (string) - The password for `ssh_username` to use to
+  authenticate with SSH. By default this is the empty string.
+
+* `ssh_port` (integer) - The port that SSH will be listening on in the guest
+  virtual machine. By default this is 22.
+
+* `ssh_wait_timeout` (string) - The duration to wait for SSH to become
+  available. By default this is "20m", or 20 minutes. Note that this should
+  be quite long since the timer begins as soon as the virtual machine is booted.
+
+* `vm_name` (string) - This is the name of the PVM directory for the new
+  virtual machine, without the file extension. By default this is
+  "packer-BUILDNAME", where "BUILDNAME" is the name of the build.
+
+## Boot Command
+
+The `boot_command` configuration is very important: it specifies the keys
+to type when the virtual machine is first booted in order to start the
+OS installer. This command is typed after `boot_wait`, which gives the
+virtual machine some time to actually load the ISO.
+
+As documented above, the `boot_command` is an array of strings. The
+strings are all typed in sequence. It is an array only to improve readability
+within the template.
+
+The boot command is "typed" character for character (using the Parallels
+Virtualization SDK, see [Parallels Builder](/docs/builders/parallels.html))
+simulating a human actually typing the keyboard. There are a set of special
+keys available. If these are in your boot command, they will be replaced by
+the proper key:
+
+* `<bs>` - Backspace
+
+* `<del>` - Delete
+
+* `<enter>` and `<return>` - Simulates an actual "enter" or "return" keypress.
+
+* `<esc>` - Simulates pressing the escape key.
+
+* `<tab>` - Simulates pressing the tab key.
+
+* `<f1>` - `<f12>` - Simulates pressing a function key.
+
+* `<up>` `<down>` `<left>` `<right>` - Simulates pressing an arrow key.
+
+* `<spacebar>` - Simulates pressing the spacebar.
+
+* `<insert>` - Simulates pressing the insert key.
+
+* `<home>` `<end>` - Simulates pressing the home and end keys.
+
+* `<pageUp>` `<pageDown>` - Simulates pressing the page up and page down keys.
+
+* `<wait>` `<wait5>` `<wait10>` - Adds a 1, 5 or 10 second pause before sending any additional keys. This
+  is useful if you have to generally wait for the UI to update before typing more.
+
+In addition to the special keys, each command to type is treated as a
+[configuration template](/docs/templates/configuration-templates.html).
+The available variables are:
+
+* `HTTPIP` and `HTTPPort` - The IP and port, respectively of an HTTP server
+  that is started serving the directory specified by the `http_directory`
+  configuration parameter. If `http_directory` isn't specified, these will
+  be blank!
+
+Example boot command. This is actually a working boot command used to start
+an Ubuntu 12.04 installer:
+
+```javascript
+[
+  "&lt;esc&gt;&lt;esc&gt;&lt;enter&gt;&lt;wait&gt;",
+  "/install/vmlinuz noapic ",
+  "preseed/url=http://{{ .HTTPIP }}:{{ .HTTPPort }}/preseed.cfg ",
+  "debian-installer=en_US auto locale=en_US kbd-chooser/method=us ",
+  "hostname={{ .Name }} ",
+  "fb=false debconf/frontend=noninteractive ",
+  "keyboard-configuration/modelcode=SKIP keyboard-configuration/layout=USA ",
+  "keyboard-configuration/variant=USA console-setup/ask_detect=false ",
+  "initrd=/install/initrd.gz -- &lt;enter&gt;"
+]
+```
+
+## prlctl Commands
+In order to perform extra customization of the virtual machine, a template can
+define extra calls to `prlctl` to perform.
+[prlctl](http://download.parallels.com/desktop/v9/ga/docs/en_US/Parallels%20Command%20Line%20Reference%20Guide.pdf)
+is the command-line interface to Parallels Desktop. It can be used to configure
+the virtual machine, such as set RAM, CPUs, etc.
+
+Extra `prlctl` commands are defined in the template in the `prlctl` section.
+An example is shown below that sets the memory and number of CPUs within the
+virtual machine:
+
+```javascript
+{
+  "prlctl": [
+    ["set", "{{.Name}}", "--memsize", "1024"],
+    ["set", "{{.Name}}", "--cpus", "2"]
+  ]
+}
+```
+
+The value of `prlctl` is an array of commands to execute. These commands are
+executed in the order defined. So in the above example, the memory will be set
+followed by the CPUs.
+
+Each command itself is an array of strings, where each string is an argument to
+`prlctl`. Each argument is treated as a
+[configuration template](/docs/templates/configuration-templates.html). The only
+available variable is `Name` which is replaced with the unique name of the VM,
+which is required for many `prlctl` calls.
diff --git a/website/source/docs/builders/parallels-pvm.html.markdown b/website/source/docs/builders/parallels-pvm.html.markdown
new file mode 100644
index 000000000..5bd1c92cf
--- /dev/null
+++ b/website/source/docs/builders/parallels-pvm.html.markdown
@@ -0,0 +1,229 @@
+---
+layout: "docs"
+page_title: "Parallels Builder (from a PVM)"
+description: |-
+  This Parallels builder is able to create Parallels Desktop for Mac virtual machines and export them in the PVM format, starting from an existing PVM (exported virtual machine image).
+---
+
+# Parallels Builder (from a PVM)
+
+Type: `parallels-pvm`
+
+This Parallels builder is able to create
+[Parallels Desktop for Mac](http://www.parallels.com/products/desktop/)
+virtual machines and export them in the PVM format, starting from an
+existing PVM (exported virtual machine image).
+
+The builder builds a virtual machine by importing an existing PVM
+file. It then boots this image, runs provisioners on this new VM, and
+exports that VM to create the image. The imported machine is deleted prior
+to finishing the build.
+
+## Basic Example
+
+Here is a basic example. This example is functional if you have an PVM matching
+the settings here.
+
+```javascript
+{
+  "type": "parallels-pvm",
+  "parallels_tools_flavor": "lin"
+  "source_path": "source.pvm",
+  "ssh_username": "packer",
+  "ssh_password": "packer",
+  "ssh_wait_timeout": "30s",
+  "shutdown_command": "echo 'packer' | sudo -S shutdown -P now"
+}
+```
+
+It is important to add a `shutdown_command`. By default Packer halts the
+virtual machine and the file system may not be sync'd. Thus, changes made in a
+provisioner might not be saved.
+
+## Configuration Reference
+
+There are many configuration options available for the Parallels builder.
+They are organized below into two categories: required and optional. Within
+each category, the available options are alphabetized and described.
+
+### Required:
+
+* `source_path` (string) - The path to a PVM directory that acts as
+  the source of this build.
+
+* `ssh_username` (string) - The username to use to SSH into the machine
+  once the OS is installed.
+
+* `parallels_tools_flavor` (string) - The flavor of the Parallels Tools ISO to
+  install into the VM. Valid values are "win", "lin", "mac", "os2" and "other".
+  This can be ommited only if `parallels_tools_mode` is "disable".
+
+### Optional:
+
+* `boot_command` (array of strings) - This is an array of commands to type
+  when the virtual machine is first booted. The goal of these commands should
+  be to type just enough to initialize the operating system installer. Special
+  keys can be typed as well, and are covered in the section below on the boot
+  command. If this is not specified, it is assumed the installer will start
+  itself.
+
+* `boot_wait` (string) - The time to wait after booting the initial virtual
+  machine before typing the `boot_command`. The value of this should be
+  a duration. Examples are "5s" and "1m30s" which will cause Packer to wait
+  five seconds and one minute 30 seconds, respectively. If this isn't specified,
+  the default is 10 seconds.
+
+* `floppy_files` (array of strings) - A list of files to put onto a floppy
+  disk that is attached when the VM is booted for the first time. This is
+  most useful for unattended Windows installs, which look for an
+  `Autounattend.xml` file on removable media. By default no floppy will
+  be attached. The files listed in this configuration will all be put
+  into the root directory of the floppy disk; sub-directories are not supported.
+
+* `reassign_mac` (boolean) - If this is "false" the MAC address of the first
+  NIC will reused when imported else a new MAC address will be generated by
+  Parallels. Defaults to "false".
+
+* `output_directory` (string) - This is the path to the directory where the
+  resulting virtual machine will be created. This may be relative or absolute.
+  If relative, the path is relative to the working directory when `packer`
+  is executed. This directory must not exist or be empty prior to running the builder.
+  By default this is "output-BUILDNAME" where "BUILDNAME" is the name
+  of the build.
+
+* `parallels_tools_guest_path` (string) - The path in the VM to upload Parallels
+  Tools. This only takes effect if `parallels_tools_mode` is not "disable".
+  This is a [configuration template](/docs/templates/configuration-templates.html)
+  that has a single valid variable: `Flavor`, which will be the value of
+  `parallels_tools_flavor`. By default the upload path is set to
+  `prl-tools-{{.Flavor}}.iso`.
+
+* `parallels_tools_mode` (string) - The method by which Parallels Tools are
+  made available to the guest for installation. Valid options are "upload",
+  "attach", or "disable". The functions of each of these should be
+  self-explanatory. The default value is "upload".
+
+* `prlctl` (array of array of strings) - Custom `prlctl` commands to execute in
+  order to further customize the virtual machine being created. The value of
+  this is an array of commands to execute. The commands are executed in the order
+  defined in the template. For each command, the command is defined itself as an
+  array of strings, where each string represents a single argument on the
+  command-line to `prlctl` (but excluding `prlctl` itself). Each arg is treated
+  as a [configuration template](/docs/templates/configuration-templates.html),
+  where the `Name` variable is replaced with the VM name. More details on how
+  to use `prlctl` are below.
+
+* `prlctl_version_file` (string) - The path within the virtual machine to upload
+  a file that contains the `prlctl` version that was used to create the machine.
+  This information can be useful for provisioning. By default this is
+  ".prlctl_version", which will generally upload it into the home directory.
+
+* `shutdown_command` (string) - The command to use to gracefully shut down
+  the machine once all the provisioning is done. By default this is an empty
+  string, which tells Packer to just forcefully shut down the machine.
+
+* `shutdown_timeout` (string) - The amount of time to wait after executing
+  the `shutdown_command` for the virtual machine to actually shut down.
+  If it doesn't shut down in this time, it is an error. By default, the timeout
+  is "5m", or five minutes.
+
+* `ssh_key_path` (string) - Path to a private key to use for authenticating
+  with SSH. By default this is not set (key-based auth won't be used).
+  The associated public key is expected to already be configured on the
+  VM being prepared by some other process (kickstart, etc.).
+
+* `ssh_password` (string) - The password for `ssh_username` to use to
+  authenticate with SSH. By default this is the empty string.
+
+* `ssh_port` (integer) - The port that SSH will be listening on in the guest
+  virtual machine. By default this is 22.
+
+* `ssh_wait_timeout` (string) - The duration to wait for SSH to become
+  available. By default this is "20m", or 20 minutes. Note that this should
+  be quite long since the timer begins as soon as the virtual machine is booted.
+
+* `vm_name` (string) - This is the name of the virtual machine when it is
+  imported as well as the name of the PVM directory when the virtual machine is
+  exported. By default this is "packer-BUILDNAME", where "BUILDNAME" is
+  the name of the build.
+
+## Parallels Tools
+After the virtual machine is up and the operating system is installed, Packer
+uploads the Parallels Tools into the virtual machine. The path where they are
+uploaded is controllable by `parallels_tools_path`, and defaults to
+"prl-tools.iso". Without an absolute path, it is uploaded to the home directory
+of the SSH user. Parallels Tools ISO's can be found in:
+"/Applications/Parallels Desktop.app/Contents/Resources/Tools/"
+
+## Boot Command
+
+The `boot_command` specifies the keys to type when the virtual machine is first booted. This command is typed after `boot_wait`.
+
+As documented above, the `boot_command` is an array of strings. The
+strings are all typed in sequence. It is an array only to improve readability
+within the template.
+
+The boot command is "typed" character for character (using the Parallels
+Virtualization SDK, see [Parallels Builder](/docs/builders/parallels.html))
+simulating a human actually typing the keyboard. There are a set of special
+keys available. If these are in your boot command, they will be replaced by
+the proper key:
+
+* `<bs>` - Backspace
+
+* `<del>` - Delete
+
+* `<enter>` and `<return>` - Simulates an actual "enter" or "return" keypress.
+
+* `<esc>` - Simulates pressing the escape key.
+
+* `<tab>` - Simulates pressing the tab key.
+
+* `<f1>` - `<f12>` - Simulates pressing a function key.
+
+* `<up>` `<down>` `<left>` `<right>` - Simulates pressing an arrow key.
+
+* `<spacebar>` - Simulates pressing the spacebar.
+
+* `<insert>` - Simulates pressing the insert key.
+
+* `<home>` `<end>` - Simulates pressing the home and end keys.
+
+* `<pageUp>` `<pageDown>` - Simulates pressing the page up and page down keys.
+
+* `<wait>` `<wait5>` `<wait10>` - Adds a 1, 5 or 10 second pause before sending any additional keys. This
+  is useful if you have to generally wait for the UI to update before typing more.
+
+In addition to the special keys, each command to type is treated as a
+[configuration template](/docs/templates/configuration-templates.html).
+The available variables are:
+
+## prlctl Commands
+In order to perform extra customization of the virtual machine, a template can
+define extra calls to `prlctl` to perform.
+[prlctl](http://download.parallels.com/desktop/v9/ga/docs/en_US/Parallels%20Command%20Line%20Reference%20Guide.pdf)
+is the command-line interface to Parallels Desktop. It can be used to configure
+the virtual machine, such as set RAM, CPUs, etc.
+
+Extra `prlctl` commands are defined in the template in the `prlctl` section.
+An example is shown below that sets the memory and number of CPUs within the
+virtual machine:
+
+```javascript
+{
+  "prlctl": [
+    ["set", "{{.Name}}", "--memsize", "1024"],
+    ["set", "{{.Name}}", "--cpus", "2"]
+  ]
+}
+```
+
+The value of `prlctl` is an array of commands to execute. These commands are
+executed in the order defined. So in the above example, the memory will be set
+followed by the CPUs.
+
+Each command itself is an array of strings, where each string is an argument to
+`prlctl`. Each argument is treated as a
+[configuration template](/docs/templates/configuration-templates.html). The only
+available variable is `Name` which is replaced with the unique name of the VM,
+which is required for many `prlctl` calls.
diff --git a/website/source/docs/builders/parallels.html.markdown b/website/source/docs/builders/parallels.html.markdown
new file mode 100644
index 000000000..db5f62139
--- /dev/null
+++ b/website/source/docs/builders/parallels.html.markdown
@@ -0,0 +1,34 @@
+---
+layout: "docs"
+page_title: "Parallels Builder"
+description: |-
+  The Parallels Packer builder is able to create Parallels Desktop for Mac virtual machines and export them in the PVM format.
+---
+
+# Parallels Builder
+
+The Parallels Packer builder is able to create [Parallels Desktop for Mac](http://www.parallels.com/products/desktop/) virtual machines and export them in the PVM format.
+
+Packer actually comes with multiple builders able to create Parallels
+machines, depending on the strategy you want to use to build the image.
+Packer supports the following Parallels builders:
+
+* [parallels-iso](/docs/builders/parallels-iso.html) - Starts from
+  an ISO file, creates a brand new Parallels VM, installs an OS,
+  provisions software within the OS, then exports that machine to create
+  an image. This is best for people who want to start from scratch.
+
+* [parallels-pvm](/docs/builders/parallels-pvm.html) - This builder
+  imports an existing PVM file, runs provisioners on top of that VM,
+  and exports that machine to create an image. This is best if you have
+  an existing Parallels VM export you want to use as the source. As an
+  additional benefit, you can feed the artifact of this builder back into
+  itself to iterate on a machine.
+
+
+## Requirements
+
+In addition to [Parallels Desktop for Mac](http://www.parallels.com/products/desktop/) this requires the
+[Parallels Virtualization SDK](http://www.parallels.com/downloads/desktop/).
+
+The SDK can be installed by downloading and following the instructions in the dmg.
diff --git a/website/source/docs/builders/qemu.html.markdown b/website/source/docs/builders/qemu.html.markdown
index d72437219..76fe9e924 100644
--- a/website/source/docs/builders/qemu.html.markdown
+++ b/website/source/docs/builders/qemu.html.markdown
@@ -1,12 +1,15 @@
 ---
 layout: "docs"
+page_title: "QEMU Builder"
+description: |-
+  The Qemu Packer builder is able to create KVM and Xen virtual machine images. Support for Xen is experimental at this time.
 ---
 
 # QEMU Builder
 
 Type: `qemu`
 
-The Qemu builder is able to create [KVM](http://www.linux-kvm.org)
+The Qemu Packer builder is able to create [KVM](http://www.linux-kvm.org)
 and [Xen](http://www.xenproject.org) virtual machine images. Support
 for Xen is experimental at this time.
 
@@ -21,14 +24,14 @@ containing the image file necessary to run the virtual machine on KVM or Xen.
 Here is a basic example. This example is functional so long as you fixup
 paths to files, URLS for ISOs and checksums.
 
-<pre class="prettyprint">
+```javascript
 {
   "builders":
   [
     {
       "type": "qemu",
-      "iso_url": "http://mirror.raystedman.net/centos/6/isos/x86_64/CentOS-6.4-x86_64-minimal.iso",
-      "iso_checksum": "4a5fa01c81cc300f4729136e28ebe600",
+      "iso_url": "http://mirror.raystedman.net/centos/6/isos/x86_64/CentOS-6.5-x86_64-minimal.iso",
+      "iso_checksum": "0d9dc37b5dd4befa1c440d2174e88a87",
       "iso_checksum_type": "md5",
       "output_directory": "output_centos_tdhtest",
       "ssh_wait_timeout": "30s",
@@ -49,18 +52,18 @@ paths to files, URLS for ISOs and checksums.
       "vm_name": "tdhtest",
       "net_device": "virtio-net",
       "disk_interface": "virtio",
+      "boot_wait": "5s",
       "boot_command":
       [
-        "<tab><wait>",
-        " ks=http://10.0.2.2:{{ .HTTPPort }}/centos6-ks.cfg<enter>"
+        "<tab> text ks=http://{{ .HTTPIP }}:{{ .HTTPPort }}/centos6-ks.cfg<enter><wait>"
       ]
     }
   ]
 }
-</pre>
+```
 
 A working CentOS 6.x kickstart file can be found
-[at this URL](https://gist.github.com/mitchellh/7328271/raw/c91e0c4fa19c171a40b016c6c8f251f90d2ad0ba/centos6-ks.cfg), adapted from an unknown source.
+[at this URL](https://gist.github.com/mitchellh/7328271/#file-centos6-ks-cfg), adapted from an unknown source.
 Place this file in the http directory with the proper name. For the
 example above, it should go into "httpdir" with a name of "centos6-ks.cfg".
 
@@ -70,7 +73,7 @@ There are many configuration options available for the Qemu builder.
 They are organized below into two categories: required and optional. Within
 each category, the available options are alphabetized and described.
 
-Required:
+### Required:
 
 * `iso_checksum` (string) - The checksum for the OS ISO file. Because ISO
   files are so large, this is required and Packer will verify it prior
@@ -88,11 +91,12 @@ Required:
 * `ssh_username` (string) - The username to use to SSH into the machine
   once the OS is installed.
 
-Optional:
+### Optional:
 
 * `accelerator` (string) - The accelerator type to use when running the VM.
-  This may have a value of either "kvm" or "xen" and you must have that
-  support in on the machine on which you run the builder.
+  This may have a value of either "none", "kvm", "tcg", or "xen" and you must have that
+  support in on the machine on which you run the builder. By default "kvm"
+  is used.
 
 * `boot_command` (array of strings) - This is an array of commands to type
   when the virtual machine is first booted. The goal of these commands should
@@ -107,7 +111,7 @@ Optional:
   five seconds and one minute 30 seconds, respectively. If this isn't specified,
   the default is 10 seconds.
 
-* `disk_size` (int) - The size, in megabytes, of the hard disk to create
+* `disk_size` (integer) - The size, in megabytes, of the hard disk to create
   for the VM. By default, this is 40000 (about 40 GB).
 
 * `disk_interface` (string) - The interface to use for the disk. Allowed
@@ -115,18 +119,24 @@ Optional:
   commands or kickstart type scripts must have proper adjustments for
   resulting device names. The Qemu builder uses "virtio" by default.
 
+* `disk_cache` (string) - The cache mode to use for disk. Allowed values
+  values include any of "writethrough", "writeback", "none", "unsafe" or
+  "directsync".
+
+* `floppy_files` (array of strings) - A list of files to place onto a floppy
+  disk that is attached when the VM is booted. This is most useful
+  for unattended Windows installs, which look for an `Autounattend.xml` file
+  on removable media. By default, no floppy will be attached. All files
+  listed in this setting get placed into the root directory of the floppy
+  and the floppy is attached as the first floppy device. Currently, no
+  support exists for creating sub-directories on the floppy. Wildcard
+  characters (*, ?, and []) are allowed. Directory names are also allowed,
+  which will add all the files found in the directory to the floppy.
+
 * `format` (string) - Either "qcow2" or "raw", this specifies the output
   format of the virtual machine image. This defaults to "qcow2".
 
-* `floppy_files` (array of strings) - A list of files to place onto a floppy
-  disk that gets attached when Packer powers up the VM. This is most useful
-  for unattended Windows installs, which look for an `Autounattend.xml` file
-  on removable media. By default no floppy will be attached. All files
-  listed in this setting get placed into the root directory of the floppy
-  and teh floppy is attached as the first floppy device. Currently, no
-  support exists for sub-directories.
-
-* `headless` (bool) - Packer defaults to building virtual machines by
+* `headless` (boolean) - Packer defaults to building virtual machines by
   launching a GUI that shows the console of the machine being built.
   When this value is set to true, the machine will start without a console.
 
@@ -138,7 +148,7 @@ Optional:
   available as variables in `boot_command`. This is covered in more detail
   below.
 
-* `http_port_min` and `http_port_max` (int) - These are the minimum and
+* `http_port_min` and `http_port_max` (integer) - These are the minimum and
   maximum port to use for the HTTP server started to serve the `http_directory`.
   Because Packer often runs in parallel, Packer will choose a randomly available
   port in this range to run the HTTP server. If you want to force the HTTP
@@ -151,29 +161,40 @@ Optional:
   must point to the same file (same checksum). By default this is empty
   and `iso_url` is used. Only one of `iso_url` or `iso_urls` can be specified.
 
+* `machine_type` (string) - The type of machine emulation to use. Run
+  your qemu binary with the flags `-machine help` to list available types
+  for your system. This defaults to "pc".
+
 * `net_device` (string) - The driver to use for the network interface. Allowed
   values "ne2k_pci," "i82551," "i82557b," "i82559er," "rtl8139," "e1000,"
   "pcnet" or "virtio." The Qemu builder uses "virtio" by default.
 
+* `output_directory` (string) - This is the path to the directory where the
+  resulting virtual machine will be created. This may be relative or absolute.
+  If relative, the path is relative to the working directory when `packer`
+  is executed. This directory must not exist or be empty prior to running the builder.
+  By default this is "output-BUILDNAME" where "BUILDNAME" is the name
+  of the build.
+
 * `qemuargs` (array of array of strings) - Allows complete control over
   the qemu command line (though not, at this time, qemu-img). Each array
   of strings makes up a command line switch that overrides matching default
   switch/value pairs. Any value specified as an empty string is ignored.
   All values after the switch are concatenated with no separater.
 
-  WARNING: The qemu command line allows extreme flexibility, so beware of
-  conflicting arguments causing failures of your run. For instance, using
-   --no-acpi could break the ability to send power signal type commands (e.g.,
-  shutdown -P now) to the virtual machine, thus preventing proper shutdown. To
-  see the defaults, look in the packer.log file and search for the
-  qemu-system-x86 command. The arguments are all printed for review.
+~> **Warning:** The qemu command line allows extreme flexibility, so beware of
+conflicting arguments causing failures of your run. For instance, using
+--no-acpi could break the ability to send power signal type commands (e.g.,
+shutdown -P now) to the virtual machine, thus preventing proper shutdown. To
+see the defaults, look in the packer.log file and search for the
+qemu-system-x86 command. The arguments are all printed for review.
 
   The following shows a sample usage:
 
-<pre class="prettyprint">
-  . . .
+```javascript
+  // ...
   "qemuargs": [
-    [ "-m", "1024m" ],
+    [ "-m", "1024M" ],
     [ "--no-acpi", "" ],
     [
        "-netdev",
@@ -183,22 +204,15 @@ Optional:
     ],
     [ "-device", "virtio-net,netdev=mynet0" ]
   ]
-  . . .
-</pre>
+  // ...
+```
 
   would produce the following (not including other defaults supplied by the builder and not otherwise conflicting with the qemuargs):
 
 <pre class="prettyprint">
-    qemu-system-x86 -m 1024m --no-acpi -netdev user,id=mynet0,hostfwd=hostip:hostport-guestip:guestport -device virtio-net,netdev=mynet0"
+	qemu-system-x86 -m 1024m --no-acpi -netdev user,id=mynet0,hostfwd=hostip:hostport-guestip:guestport -device virtio-net,netdev=mynet0"
 </pre>
 
-* `output_directory` (string) - This is the path to the directory where the
-  resulting virtual machine will be created. This may be relative or absolute.
-  If relative, the path is relative to the working directory when `packer`
-  is executed. This directory must not exist or be empty prior to running the builder.
-  By default this is "output-BUILDNAME" where "BUILDNAME" is the name
-  of the build.
-
 * `qemu_binary` (string) - The name of the Qemu binary to look for.  This
   defaults to "qemu-system-x86_64", but may need to be changed for some
   platforms.  For example "qemu-kvm", or "qemu-system-i386" may be a better
@@ -227,7 +241,7 @@ Optional:
 * `ssh_password` (string) - The password for `ssh_username` to use to
   authenticate with SSH. By default this is the empty string.
 
-* `ssh_port` (int) - The port that SSH will be listening on in the guest
+* `ssh_port` (integer) - The port that SSH will be listening on in the guest
   virtual machine. By default this is 22. The Qemu builder will map, via
   port forward, a port on the host machine to the port listed here so
   machines outside the installing VM can access the VM.
@@ -240,6 +254,17 @@ Optional:
   the new virtual machine, without the file extension. By default this is
   "packer-BUILDNAME", where "BUILDNAME" is the name of the build.
 
+* `vnc_port_min` and `vnc_port_max` (integer) - The minimum and
+  maximum port to use for the VNC port on the host machine which is forwarded
+  to the VNC port on the guest machine. Because Packer often runs in parallel,
+  Packer will choose a randomly available port in this range to use as the
+  host port.
+
+* `disk_image` (boolean) - Packer defaults to building from an ISO file,
+  this parameter controls whether the ISO URL supplied is actually a bootable
+  QEMU image.  When this value is set to true, the machine will clone the
+  source, resize it according to `disk_size` and boot the image.
+
 ## Boot Command
 
 The `boot_command` configuration is very important: it specifies the keys
@@ -256,12 +281,28 @@ to the machine, simulating a human actually typing the keyboard. There are
 a set of special keys available. If these are in your boot command, they
 will be replaced by the proper key:
 
+* `<bs>` - Backspace
+
+* `<del>` - Delete
+
 * `<enter>` and `<return>` - Simulates an actual "enter" or "return" keypress.
 
 * `<esc>` - Simulates pressing the escape key.
 
 * `<tab>` - Simulates pressing the tab key.
 
+* `<f1>` - `<f12>` - Simulates pressing a function key.
+
+* `<up>` `<down>` `<left>` `<right>` - Simulates pressing an arrow key.
+
+* `<spacebar>` - Simulates pressing the spacebar.
+
+* `<insert>` - Simulates pressing the insert key.
+
+* `<home>` `<end>` - Simulates pressing the home and end keys.
+
+* `<pageUp>` `<pageDown>` - Simulates pressing the page up and page down keys.
+
 * `<wait>` `<wait5>` `<wait10>` - Adds a 1, 5 or 10 second pause before sending any additional keys. This
   is useful if you have to generally wait for the UI to update before typing more.
 
@@ -277,10 +318,10 @@ The available variables are:
 Example boot command. This is actually a working boot command used to start
 an CentOS 6.4 installer:
 
-<pre class="prettyprint">
+```javascript
 "boot_command":
 [
   "<tab><wait>",
   " ks=http://10.0.2.2:{{ .HTTPPort }}/centos6-ks.cfg<enter>"
 ]
-</pre>
+```
diff --git a/website/source/docs/builders/virtualbox-iso.html.markdown b/website/source/docs/builders/virtualbox-iso.html.markdown
index 3c2e87e7f..f7e56345f 100644
--- a/website/source/docs/builders/virtualbox-iso.html.markdown
+++ b/website/source/docs/builders/virtualbox-iso.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "VirtualBox Builder (from an ISO)"
+description: |-
+  The VirtualBox Packer builder is able to create VirtualBox virtual machines and export them in the OVF format, starting from an ISO image.
 ---
 
 # VirtualBox Builder (from an ISO)
 
 Type: `virtualbox-iso`
 
-The VirtualBox builder is able to create [VirtualBox](https://www.virtualbox.org/)
+The VirtualBox Packer builder is able to create [VirtualBox](https://www.virtualbox.org/)
 virtual machines and export them in the OVF format, starting from an
 ISO image.
 
@@ -22,19 +24,19 @@ Here is a basic example. This example is not functional. It will start the
 OS installer but then fail because we don't provide the preseed file for
 Ubuntu to self-install. Still, the example serves to show the basic configuration:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "virtualbox-iso",
   "guest_os_type": "Ubuntu_64",
-  "iso_url": "http://releases.ubuntu.com/12.04/ubuntu-12.04.3-server-amd64.iso",
-  "iso_checksum": "2cbe868812a871242cdcdd8f2fd6feb9",
+  "iso_url": "http://releases.ubuntu.com/12.04/ubuntu-12.04.5-server-amd64.iso",
+  "iso_checksum": "769474248a3897f4865817446f9a4a53",
   "iso_checksum_type": "md5",
   "ssh_username": "packer",
   "ssh_password": "packer",
   "ssh_wait_timeout": "30s",
   "shutdown_command": "echo 'packer' | sudo -S shutdown -P now"
 }
-</pre>
+```
 
 It is important to add a `shutdown_command`. By default Packer halts the
 virtual machine and the file system may not be sync'd. Thus, changes made in a
@@ -46,7 +48,7 @@ There are many configuration options available for the VirtualBox builder.
 They are organized below into two categories: required and optional. Within
 each category, the available options are alphabetized and described.
 
-Required:
+### Required:
 
 * `iso_checksum` (string) - The checksum for the OS ISO file. Because ISO
   files are so large, this is required and Packer will verify it prior
@@ -67,7 +69,7 @@ Required:
 * `ssh_username` (string) - The username to use to SSH into the machine
   once the OS is installed.
 
-Optional:
+### Optional:
 
 * `boot_command` (array of strings) - This is an array of commands to type
   when the virtual machine is first booted. The goal of these commands should
@@ -82,15 +84,22 @@ Optional:
   five seconds and one minute 30 seconds, respectively. If this isn't specified,
   the default is 10 seconds.
 
-* `disk_size` (int) - The size, in megabytes, of the hard disk to create
+* `disk_size` (integer) - The size, in megabytes, of the hard disk to create
   for the VM. By default, this is 40000 (about 40 GB).
 
-* `floppy_files` (array of strings) - A list of files to put onto a floppy
-  disk that is attached when the VM is booted for the first time. This is
-  most useful for unattended Windows installs, which look for an
-  `Autounattend.xml` file on removable media. By default no floppy will
-  be attached. The files listed in this configuration will all be put
-  into the root directory of the floppy disk; sub-directories are not supported.
+* `export_opts` (array of strings) - Additional options to pass to the `VBoxManage export`.
+  This can be useful for passing product information to include in the resulting
+  appliance file.
+
+* `floppy_files` (array of strings) - A list of files to place onto a floppy
+  disk that is attached when the VM is booted. This is most useful
+  for unattended Windows installs, which look for an `Autounattend.xml` file
+  on removable media. By default, no floppy will be attached. All files
+  listed in this setting get placed into the root directory of the floppy
+  and the floppy is attached as the first floppy device. Currently, no
+  support exists for creating sub-directories on the floppy. Wildcard
+  characters (*, ?, and []) are allowed. Directory names are also allowed,
+  which will add all the files found in the directory to the floppy.
 
 * `format` (string) - Either "ovf" or "ova", this specifies the output
   format of the exported virtual machine. This defaults to "ovf".
@@ -114,8 +123,9 @@ Optional:
 
 * `guest_additions_url` (string) - The URL to the guest additions ISO
   to upload. This can also be a file URL if the ISO is at a local path.
-  By default the VirtualBox builder will go and download the proper
-  guest additions ISO from the internet.
+  By default, the VirtualBox builder will attempt to find the guest additions
+  ISO on the local file system. If it is not available locally, the builder
+  will download the proper guest additions ISO from the internet.
 
 * `guest_os_type` (string) - The guest OS type being installed. By default
   this is "other", but you can get _dramatic_ performance improvements by
@@ -128,7 +138,7 @@ Optional:
   hard drive is attached to, defaults to "ide".  When set to "sata", the
   drive is attached to an AHCI SATA controller.
 
-* `headless` (bool) - Packer defaults to building VirtualBox
+* `headless` (boolean) - Packer defaults to building VirtualBox
   virtual machines by launching a GUI that shows the console of the
   machine being built. When this value is set to true, the machine will
   start without a console.
@@ -141,13 +151,17 @@ Optional:
   available as variables in `boot_command`. This is covered in more detail
   below.
 
-* `http_port_min` and `http_port_max` (int) - These are the minimum and
+* `http_port_min` and `http_port_max` (integer) - These are the minimum and
   maximum port to use for the HTTP server started to serve the `http_directory`.
   Because Packer often runs in parallel, Packer will choose a randomly available
   port in this range to run the HTTP server. If you want to force the HTTP
   server to be on one port, make this minimum and maximum port the same.
   By default the values are 8000 and 9000, respectively.
 
+* `iso_interface` (string) - The type of controller that the ISO is attached
+  to, defaults to "ide".  When set to "sata", the drive is attached to an
+  AHCI SATA controller.
+
 * `iso_urls` (array of strings) - Multiple URLs for the ISO to download.
   Packer will try these in order. If anything goes wrong attempting to download
   or while downloading a single URL, it will move on to the next. All URLs
@@ -170,7 +184,7 @@ Optional:
   If it doesn't shut down in this time, it is an error. By default, the timeout
   is "5m", or five minutes.
 
-* `ssh_host_port_min` and `ssh_host_port_max` (uint) - The minimum and
+* `ssh_host_port_min` and `ssh_host_port_max` (integer) - The minimum and
   maximum port to use for the SSH port on the host machine which is forwarded
   to the SSH port on the guest machine. Because Packer often runs in parallel,
   Packer will choose a randomly available port in this range to use as the
@@ -184,7 +198,7 @@ Optional:
 * `ssh_password` (string) - The password for `ssh_username` to use to
   authenticate with SSH. By default this is the empty string.
 
-* `ssh_port` (int) - The port that SSH will be listening on in the guest
+* `ssh_port` (integer) - The port that SSH will be listening on in the guest
   virtual machine. By default this is 22.
 
 * `ssh_wait_timeout` (string) - The duration to wait for SSH to become
@@ -205,20 +219,20 @@ Optional:
   where the `Name` variable is replaced with the VM name. More details on how
   to use `VBoxManage` are below.
 
+* `vboxmanage_post` (array of array of strings) - Identical to `vboxmanage`,
+  except that it is run after the virtual machine is shutdown, and before the
+  virtual machine is exported.
+
 * `virtualbox_version_file` (string) - The path within the virtual machine
   to upload a file that contains the VirtualBox version that was used to
   create the machine. This information can be useful for provisioning.
-  By default this is ".vbox_version", which will generally upload it into
+  By default this is ".vbox_version", which will generally be upload it into
   the home directory.
 
 * `vm_name` (string) - This is the name of the OVF file for the new virtual
   machine, without the file extension. By default this is "packer-BUILDNAME",
   where "BUILDNAME" is the name of the build.
 
-* `export_opts` (array of strings) - Additional options to pass to the `VBoxManage export`.
-  This can be useful for passing product information to include in the resulting
-  appliance file.
-
 ## Boot Command
 
 The `boot_command` configuration is very important: it specifies the keys
@@ -235,12 +249,28 @@ to the machine, simulating a human actually typing the keyboard. There are
 a set of special keys available. If these are in your boot command, they
 will be replaced by the proper key:
 
+* `<bs>` - Backspace
+
+* `<del>` - Delete
+
 * `<enter>` and `<return>` - Simulates an actual "enter" or "return" keypress.
 
 * `<esc>` - Simulates pressing the escape key.
 
 * `<tab>` - Simulates pressing the tab key.
 
+* `<f1>` - `<f12>` - Simulates pressing a function key.
+
+* `<up>` `<down>` `<left>` `<right>` - Simulates pressing an arrow key.
+
+* `<spacebar>` - Simulates pressing the spacebar.
+
+* `<insert>` - Simulates pressing the insert key.
+
+* `<home>` `<end>` - Simulates pressing the home and end keys.
+
+* `<pageUp>` `<pageDown>` - Simulates pressing the page up and page down keys.
+
 * `<wait>` `<wait5>` `<wait10>` - Adds a 1, 5 or 10 second pause before sending any additional keys. This
   is useful if you have to generally wait for the UI to update before typing more.
 
@@ -256,7 +286,7 @@ The available variables are:
 Example boot command. This is actually a working boot command used to start
 an Ubuntu 12.04 installer:
 
-<pre class="prettyprint">
+```javascript
 [
   "&lt;esc&gt;&lt;esc&gt;&lt;enter&gt;&lt;wait&gt;",
   "/install/vmlinuz noapic ",
@@ -268,7 +298,7 @@ an Ubuntu 12.04 installer:
   "keyboard-configuration/variant=USA console-setup/ask_detect=false ",
   "initrd=/install/initrd.gz -- &lt;enter&gt;"
 ]
-</pre>
+```
 
 ## Guest Additions
 
@@ -296,14 +326,14 @@ Extra VBoxManage commands are defined in the template in the `vboxmanage` sectio
 An example is shown below that sets the memory and number of CPUs within the
 virtual machine:
 
-<pre class="prettyprint">
+```javascript
 {
   "vboxmanage": [
     ["modifyvm", "{{.Name}}", "--memory", "1024"],
     ["modifyvm", "{{.Name}}", "--cpus", "2"]
   ]
 }
-</pre>
+```
 
 The value of `vboxmanage` is an array of commands to execute. These commands
 are executed in the order defined. So in the above example, the memory will be
diff --git a/website/source/docs/builders/virtualbox-ovf.html.markdown b/website/source/docs/builders/virtualbox-ovf.html.markdown
index 43ce70339..08d10f2ba 100644
--- a/website/source/docs/builders/virtualbox-ovf.html.markdown
+++ b/website/source/docs/builders/virtualbox-ovf.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "VirtualBox Builder (from an OVF/OVA)"
+description: |-
+  This VirtualBox Packer builder is able to create VirtualBox virtual machines and export them in the OVF format, starting from an existing OVF/OVA (exported virtual machine image).
 ---
 
 # VirtualBox Builder (from an OVF/OVA)
 
 Type: `virtualbox-ovf`
 
-This VirtualBox builder is able to create [VirtualBox](https://www.virtualbox.org/)
+This VirtualBox Packer builder is able to create [VirtualBox](https://www.virtualbox.org/)
 virtual machines and export them in the OVF format, starting from an
 existing OVF/OVA (exported virtual machine image).
 
@@ -21,7 +23,7 @@ to finishing the build.
 Here is a basic example. This example is functional if you have an OVF matching
 the settings here.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "virtualbox-ovf",
   "source_path": "source.ovf",
@@ -30,7 +32,7 @@ the settings here.
   "ssh_wait_timeout": "30s",
   "shutdown_command": "echo 'packer' | sudo -S shutdown -P now"
 }
-</pre>
+```
 
 It is important to add a `shutdown_command`. By default Packer halts the
 virtual machine and the file system may not be sync'd. Thus, changes made in a
@@ -42,7 +44,7 @@ There are many configuration options available for the VirtualBox builder.
 They are organized below into two categories: required and optional. Within
 each category, the available options are alphabetized and described.
 
-Required:
+### Required:
 
 * `source_path` (string) - The path to an OVF or OVA file that acts as
   the source of this build.
@@ -50,14 +52,34 @@ Required:
 * `ssh_username` (string) - The username to use to SSH into the machine
   once the OS is installed.
 
-Optional:
+### Optional:
 
-* `floppy_files` (array of strings) - A list of files to put onto a floppy
-  disk that is attached when the VM is booted for the first time. This is
-  most useful for unattended Windows installs, which look for an
-  `Autounattend.xml` file on removable media. By default no floppy will
-  be attached. The files listed in this configuration will all be put
-  into the root directory of the floppy disk; sub-directories are not supported.
+* `boot_command` (array of strings) - This is an array of commands to type
+  when the virtual machine is first booted. The goal of these commands should
+  be to type just enough to initialize the operating system installer. Special
+  keys can be typed as well, and are covered in the section below on the boot
+  command. If this is not specified, it is assumed the installer will start
+  itself.
+
+* `boot_wait` (string) - The time to wait after booting the initial virtual
+  machine before typing the `boot_command`. The value of this should be
+  a duration. Examples are "5s" and "1m30s" which will cause Packer to wait
+  five seconds and one minute 30 seconds, respectively. If this isn't specified,
+  the default is 10 seconds.
+
+* `export_opts` (array of strings) - Additional options to pass to the `VBoxManage export`.
+  This can be useful for passing product information to include in the resulting
+  appliance file.
+
+* `floppy_files` (array of strings) - A list of files to place onto a floppy
+  disk that is attached when the VM is booted. This is most useful
+  for unattended Windows installs, which look for an `Autounattend.xml` file
+  on removable media. By default, no floppy will be attached. All files
+  listed in this setting get placed into the root directory of the floppy
+  and the floppy is attached as the first floppy device. Currently, no
+  support exists for creating sub-directories on the floppy. Wildcard
+  characters (*, ?, and []) are allowed. Directory names are also allowed,
+  which will add all the files found in the directory to the floppy.
 
 * `format` (string) - Either "ovf" or "ova", this specifies the output
   format of the exported virtual machine. This defaults to "ovf".
@@ -84,11 +106,34 @@ Optional:
   By default the VirtualBox builder will go and download the proper
   guest additions ISO from the internet.
 
-* `headless` (bool) - Packer defaults to building VirtualBox
+* `headless` (boolean) - Packer defaults to building VirtualBox
   virtual machines by launching a GUI that shows the console of the
   machine being built. When this value is set to true, the machine will
   start without a console.
 
+* `http_directory` (string) - Path to a directory to serve using an HTTP
+  server. The files in this directory will be available over HTTP that will
+  be requestable from the virtual machine. This is useful for hosting
+  kickstart files and so on. By default this is "", which means no HTTP
+  server will be started. The address and port of the HTTP server will be
+  available as variables in `boot_command`. This is covered in more detail
+  below.
+
+* `http_port_min` and `http_port_max` (integer) - These are the minimum and
+  maximum port to use for the HTTP server started to serve the `http_directory`.
+  Because Packer often runs in parallel, Packer will choose a randomly available
+  port in this range to run the HTTP server. If you want to force the HTTP
+  server to be on one port, make this minimum and maximum port the same.
+  By default the values are 8000 and 9000, respectively.
+
+* `import_flags` (array of strings) - Additional flags to pass to
+    `VBoxManage import`. This can be used to add additional command-line flags
+    such as `--eula-accept` to accept a EULA in the OVF.
+
+* `import_opts` (string) - Additional options to pass to the `VBoxManage import`.
+  This can be useful for passing "keepallmacs" or "keepnatmacs" options for existing
+  ovf images.
+
 * `output_directory` (string) - This is the path to the directory where the
   resulting virtual machine will be created. This may be relative or absolute.
   If relative, the path is relative to the working directory when `packer`
@@ -105,7 +150,7 @@ Optional:
   If it doesn't shut down in this time, it is an error. By default, the timeout
   is "5m", or five minutes.
 
-* `ssh_host_port_min` and `ssh_host_port_max` (uint) - The minimum and
+* `ssh_host_port_min` and `ssh_host_port_max` (integer) - The minimum and
   maximum port to use for the SSH port on the host machine which is forwarded
   to the SSH port on the guest machine. Because Packer often runs in parallel,
   Packer will choose a randomly available port in this range to use as the
@@ -119,7 +164,7 @@ Optional:
 * `ssh_password` (string) - The password for `ssh_username` to use to
   authenticate with SSH. By default this is the empty string.
 
-* `ssh_port` (int) - The port that SSH will be listening on in the guest
+* `ssh_port` (integer) - The port that SSH will be listening on in the guest
   virtual machine. By default this is 22.
 
 * `ssh_wait_timeout` (string) - The duration to wait for SSH to become
@@ -140,10 +185,14 @@ Optional:
   where the `Name` variable is replaced with the VM name. More details on how
   to use `VBoxManage` are below.
 
+* `vboxmanage_post` (array of array of strings) - Identical to `vboxmanage`,
+  except that it is run after the virtual machine is shutdown, and before the
+  virtual machine is exported.
+
 * `virtualbox_version_file` (string) - The path within the virtual machine
   to upload a file that contains the VirtualBox version that was used to
   create the machine. This information can be useful for provisioning.
-  By default this is ".vbox_version", which will generally upload it into
+  By default this is ".vbox_version", which will generally be upload it into
   the home directory.
 
 * `vm_name` (string) - This is the name of the virtual machine when it is
@@ -151,14 +200,6 @@ Optional:
   exported. By default this is "packer-BUILDNAME", where "BUILDNAME" is
   the name of the build.
 
-* `import_opts` (string) - Additional options to pass to the `VBoxManage import`.
-  This can be useful for passing "keepallmacs" or "keepnatmacs" options for existing
-  ovf images.
-
-* `export_opts` (array of strings) - Additional options to pass to the `VBoxManage export`.
-  This can be useful for passing product information to include in the resulting
-  appliance file.
-
 ## Guest Additions
 
 Packer will automatically download the proper guest additions for the
@@ -185,14 +226,14 @@ Extra VBoxManage commands are defined in the template in the `vboxmanage` sectio
 An example is shown below that sets the memory and number of CPUs within the
 virtual machine:
 
-<pre class="prettyprint">
+```javascript
 {
   "vboxmanage": [
     ["modifyvm", "{{.Name}}", "--memory", "1024"],
     ["modifyvm", "{{.Name}}", "--cpus", "2"]
   ]
 }
-</pre>
+```
 
 The value of `vboxmanage` is an array of commands to execute. These commands
 are executed in the order defined. So in the above example, the memory will be
diff --git a/website/source/docs/builders/virtualbox.html.markdown b/website/source/docs/builders/virtualbox.html.markdown
index 4a81c67f3..26e94b5b8 100644
--- a/website/source/docs/builders/virtualbox.html.markdown
+++ b/website/source/docs/builders/virtualbox.html.markdown
@@ -1,11 +1,13 @@
 ---
 layout: "docs"
 page_title: "VirtualBox Builder"
+description: |-
+  The VirtualBox Packer builder is able to create VirtualBox virtual machines and export them in the OVA or OVF format.
 ---
 
 # VirtualBox Builder
 
-The VirtualBox builder is able to create [VirtualBox](http://www.virtualbox.org)
+The VirtualBox Packer builder is able to create [VirtualBox](http://www.virtualbox.org)
 virtual machines and export them in the OVA or OVF format.
 
 Packer actually comes with multiple builders able to create VirtualBox
diff --git a/website/source/docs/builders/vmware-iso.html.markdown b/website/source/docs/builders/vmware-iso.html.markdown
index dd545f56a..61ef31cf7 100644
--- a/website/source/docs/builders/vmware-iso.html.markdown
+++ b/website/source/docs/builders/vmware-iso.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "VMware Builder from ISO"
+description: |-
+  This VMware Packer builder is able to create VMware virtual machines from an ISO file as a source. It currently supports building virtual machines on hosts running VMware Fusion for OS X, VMware Workstation for Linux and Windows, and VMware Player on Linux. It can also build machines directly on VMware vSphere Hypervisor using SSH as opposed to the vSphere API.
 ---
 
 # VMware Builder (from ISO)
 
 Type: `vmware-iso`
 
-This VMware builder is able to create VMware virtual machines from an
+This VMware Packer builder is able to create VMware virtual machines from an
 ISO file as a source. It currently
 supports building virtual machines on hosts running
 [VMware Fusion](http://www.vmware.com/products/fusion/overview.html) for OS X,
@@ -29,7 +31,7 @@ Here is a basic example. This example is not functional. It will start the
 OS installer but then fail because we don't provide the preseed file for
 Ubuntu to self-install. Still, the example serves to show the basic configuration:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "vmware-iso",
   "iso_url": "http://old-releases.ubuntu.com/releases/precise/ubuntu-12.04.2-server-amd64.iso",
@@ -39,7 +41,7 @@ Ubuntu to self-install. Still, the example serves to show the basic configuratio
   "ssh_wait_timeout": "30s",
   "shutdown_command": "shutdown -P now"
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -47,7 +49,7 @@ There are many configuration options available for the VMware builder.
 They are organized below into two categories: required and optional. Within
 each category, the available options are alphabetized and described.
 
-Required:
+### Required:
 
 * `iso_checksum` (string) - The checksum for the OS ISO file. Because ISO
   files are so large, this is required and Packer will verify it prior
@@ -68,7 +70,7 @@ Required:
 * `ssh_username` (string) - The username to use to SSH into the machine
   once the OS is installed.
 
-Optional:
+### Optional:
 
 * `boot_command` (array of strings) - This is an array of commands to type
   when the virtual machine is firsted booted. The goal of these commands should
@@ -83,7 +85,7 @@ Optional:
   five seconds and one minute 30 seconds, respectively. If this isn't specified,
   the default is 10 seconds.
 
-* `disk_size` (int) - The size of the hard disk for the VM in megabytes.
+* `disk_size` (integer) - The size of the hard disk for the VM in megabytes.
   The builder uses expandable, not fixed-size virtual hard disks, so the
   actual file representing the disk will not use the full size unless it is full.
   By default this is set to 40,000 (about 40 GB).
@@ -95,12 +97,15 @@ Optional:
   [Virtual Disk Manager User's Guide](http://www.vmware.com/pdf/VirtualDiskManager.pdf)
   for desktop VMware clients. For ESXi, refer to the proper ESXi documentation.
 
-* `floppy_files` (array of strings) - A list of files to put onto a floppy
-  disk that is attached when the VM is booted for the first time. This is
-  most useful for unattended Windows installs, which look for an
-  `Autounattend.xml` file on removable media. By default no floppy will
-  be attached. The files listed in this configuration will all be put
-  into the root directory of the floppy disk; sub-directories are not supported.
+* `floppy_files` (array of strings) - A list of files to place onto a floppy
+  disk that is attached when the VM is booted. This is most useful
+  for unattended Windows installs, which look for an `Autounattend.xml` file
+  on removable media. By default, no floppy will be attached. All files
+  listed in this setting get placed into the root directory of the floppy
+  and the floppy is attached as the first floppy device. Currently, no
+  support exists for creating sub-directories on the floppy. Wildcard
+  characters (*, ?, and []) are allowed. Directory names are also allowed,
+  which will add all the files found in the directory to the floppy.
 
 * `fusion_app_path` (string) - Path to "VMware Fusion.app". By default this
   is "/Applications/VMware Fusion.app" but this setting allows you to
@@ -111,7 +116,7 @@ Optional:
   OS type, VMware may perform some optimizations or virtual hardware changes
   to better support the operating system running in the virtual machine.
 
-* `headless` (bool) - Packer defaults to building VMware
+* `headless` (boolean) - Packer defaults to building VMware
   virtual machines by launching a GUI that shows the console of the
   machine being built. When this value is set to true, the machine will
   start without a console. For VMware machines, Packer will output VNC
@@ -126,7 +131,7 @@ Optional:
   available as variables in `boot_command`. This is covered in more detail
   below.
 
-* `http_port_min` and `http_port_max` (int) - These are the minimum and
+* `http_port_min` and `http_port_max` (integer) - These are the minimum and
   maximum port to use for the HTTP server started to serve the `http_directory`.
   Because Packer often runs in parallel, Packer will choose a randomly available
   port in this range to run the HTTP server. If you want to force the HTTP
@@ -146,10 +151,15 @@ Optional:
   By default this is "output-BUILDNAME" where "BUILDNAME" is the name
   of the build.
 
-* `remote_type` (string) - The type of remote machine that will be used to
-  build this VM rather than a local desktop product. The only value accepted
-  for this currently is "esx5". If this is not set, a desktop product will be
-  used. By default, this is not set.
+* `remote_cache_datastore` (string) - The path to the datastore where
+  supporting files will be stored during the build on the remote machine.
+  By default this is the same as the `remote_datastore` option. This only
+  has an effect if `remote_type` is enabled.
+
+* `remote_cache_directory` (string) - The path where the ISO and/or floppy
+  files will be stored during the build on the remote machine. The path is
+  relative to the `remote_cache_datastore` on the remote machine.  By default
+  this is "packer_cache". This only has an effect if `remote_type` is enabled.
 
 * `remote_datastore` (string) - The path to the datastore where the resulting
   VM will be stored when it is built on the remote machine. By default this
@@ -162,15 +172,14 @@ Optional:
   access the remote machine. By default this is empty. This only has an
   effect if `remote_type` is enabled.
 
+* `remote_type` (string) - The type of remote machine that will be used to
+  build this VM rather than a local desktop product. The only value accepted
+  for this currently is "esx5". If this is not set, a desktop product will be
+  used. By default, this is not set.
+
 * `remote_username` (string) - The username for the SSH user that will access
   the remote machine. This is required if `remote_type` is enabled.
 
-* `skip_compaction` (bool) -  VMware-created disks are defragmented
-  and compacted at the end of the build process using `vmware-vdiskmanager`.
-  In certain rare cases, this might actually end up making the resulting disks
-  slightly larger. If you find this to be the case, you can disable compaction
-  using this configuration value.
-
 * `shutdown_command` (string) - The command to use to gracefully shut down
   the machine once all the provisioning is done. By default this is an empty
   string, which tells Packer to just forcefully shut down the machine.
@@ -180,21 +189,27 @@ Optional:
   If it doesn't shut down in this time, it is an error. By default, the timeout
   is "5m", or five minutes.
 
+* `skip_compaction` (boolean) -  VMware-created disks are defragmented
+  and compacted at the end of the build process using `vmware-vdiskmanager`.
+  In certain rare cases, this might actually end up making the resulting disks
+  slightly larger. If you find this to be the case, you can disable compaction
+  using this configuration value.
+
+* `ssh_host` (string) - Hostname or IP address of the host. By default, DHCP
+  is used to connect to the host and this field is not used.
+
 * `ssh_key_path` (string) - Path to a private key to use for authenticating
   with SSH. By default this is not set (key-based auth won't be used).
   The associated public key is expected to already be configured on the
   VM being prepared by some other process (kickstart, etc.).
 
-* `ssh_host` (string) - Hostname or IP address of the host. By default, DHCP
-  is used to connect to the host and this field is not used. 
-
 * `ssh_password` (string) - The password for `ssh_username` to use to
   authenticate with SSH. By default this is the empty string.
 
-* `ssh_port` (int) - The port that SSH will listen on within the virtual
+* `ssh_port` (integer) - The port that SSH will listen on within the virtual
   machine. By default this is 22.
 
-* `ssh_skip_request_pty` (bool) - If true, a pty will not be requested as
+* `ssh_skip_request_pty` (boolean) - If true, a pty will not be requested as
   part of the SSH connection. By default, this is "false", so a pty
   _will_ be requested.
 
@@ -213,6 +228,8 @@ Optional:
   `tools_upload_flavor`. By default the upload path is set to
   `{{.Flavor}}.iso`.
 
+* `version` (string) - The [vmx hardware version](http://kb.vmware.com/selfservice/microsites/search.do?language=en_US&cmd=displayKC&externalId=1003746) for the new virtual machine.  Only the default value has been tested, any other value is expiermental.  Default value is '9'.
+
 * `vm_name` (string) - This is the name of the VMX file for the new virtual
   machine, without the file extension. By default this is "packer-BUILDNAME",
   where "BUILDNAME" is the name of the build.
@@ -220,15 +237,13 @@ Optional:
 * `vmdk_name` (string) - The filename of the virtual disk that'll be created,
   without the extension. This defaults to "packer".
 
-* `vmx_data` (object, string keys and string values) - Arbitrary key/values
+* `vmx_data` (object of key/value strings) - Arbitrary key/values
   to enter into the virtual machine VMX file. This is for advanced users
   who want to set properties such as memory, CPU, etc.
 
-* `vnc_port_min` and `vnc_port_max` (int) - The minimum and maximum port to
-  use for VNC access to the virtual machine. The builder uses VNC to type
-  the initial `boot_command`. Because Packer generally runs in parallel, Packer
-  uses a randomly chosen port in this range that appears available. By default
-  this is 5900 to 6000. The minimum and maximum ports are inclusive.
+* `vmx_data_post` (object of key/value strings) - Identical to `vmx_data`,
+  except that it is run after the virtual machine is shutdown, and before the
+  virtual machine is exported.
 
 * `vmx_template_path` (string) - Path to a
   [configuration template](/docs/templates/configuration-templates.html) that
@@ -237,6 +252,12 @@ Optional:
   non-functional. See below for more information. For basic VMX modifications,
   try `vmx_data` first.
 
+* `vnc_port_min` and `vnc_port_max` (integer) - The minimum and maximum port to
+  use for VNC access to the virtual machine. The builder uses VNC to type
+  the initial `boot_command`. Because Packer generally runs in parallel, Packer
+  uses a randomly chosen port in this range that appears available. By default
+  this is 5900 to 6000. The minimum and maximum ports are inclusive.
+
 ## Boot Command
 
 The `boot_command` configuration is very important: it specifies the keys
@@ -253,12 +274,28 @@ to the machine, simulating a human actually typing the keyboard. There are
 a set of special keys available. If these are in your boot command, they
 will be replaced by the proper key:
 
+* `<bs>` - Backspace
+
+* `<del>` - Delete
+
 * `<enter>` and `<return>` - Simulates an actual "enter" or "return" keypress.
 
 * `<esc>` - Simulates pressing the escape key.
 
 * `<tab>` - Simulates pressing the tab key.
 
+* `<f1>` - `<f12>` - Simulates pressing a function key.
+
+* `<up>` `<down>` `<left>` `<right>` - Simulates pressing an arrow key.
+
+* `<spacebar>` - Simulates pressing the spacebar.
+
+* `<insert>` - Simulates pressing the insert key.
+
+* `<home>` `<end>` - Simulates pressing the home and end keys.
+
+* `<pageUp>` `<pageDown>` - Simulates pressing the page up and page down keys.
+
 * `<wait>` `<wait5>` `<wait10>` - Adds a 1, 5 or 10 second pause before sending any additional keys. This
   is useful if you have to generally wait for the UI to update before typing more.
 
@@ -274,7 +311,7 @@ The available variables are:
 Example boot command. This is actually a working boot command used to start
 an Ubuntu 12.04 installer:
 
-<pre class="prettyprint">
+```javascript
 [
   "&lt;esc&gt;&lt;esc&gt;&lt;enter&gt;&lt;wait&gt;",
   "/install/vmlinuz noapic ",
@@ -286,7 +323,7 @@ an Ubuntu 12.04 installer:
   "keyboard-configuration/variant=USA console-setup/ask_detect=false ",
   "initrd=/install/initrd.gz -- &lt;enter&gt;"
 ]
-</pre>
+```
 
 ## VMX Template
 
@@ -297,13 +334,9 @@ But for advanced users, this template can be customized. This allows
 Packer to build virtual machines of effectively any guest operating system
 type.
 
-<div class="alert alert-block alert-warn">
-<p>
-<strong>This is an advanced feature.</strong> Modifying the VMX template
+~> **This is an advanced feature.** Modifying the VMX template
 can easily cause your virtual machine to not boot properly. Please only
 modify the template if you know what you're doing.
-</p>
-</div>
 
 Within the template, a handful of variables are available so that your
 template can continue working with the rest of the Packer machinery. Using
@@ -313,6 +346,7 @@ these variables isn't required, however.
 * `GuestOS` - The VMware-valid guest OS type.
 * `DiskName` - The filename (without the suffix) of the main virtual disk.
 * `ISOPath` - The path to the ISO to use for the OS installation.
+* `Version` - The Hardware version VMWare will execute this vm under.  Also known as the `virtualhw.version`.
 
 ## Building on a Remote vSphere Hypervisor
 
@@ -320,11 +354,24 @@ In addition to using the desktop products of VMware locally to build
 virtual machines, Packer can use a remote VMware Hypervisor to build
 the virtual machine.
 
+-> **Note:** Packer supports ESXi 5.1 and above.
+
+Before using a remote vSphere Hypervisor, you need to enable GuestIPHack by running the following command:
+
+```text
+esxcli system settings advanced set -o /Net/GuestIPHack -i 1
+```
+
 When using a remote VMware Hypervisor, the builder still downloads the
 ISO and various files locally, and uploads these to the remote machine.
 Packer currently uses SSH to communicate to the ESXi machine rather than
 the vSphere API. At some point, the vSphere API may be used.
 
+Packer also requires VNC to issue boot commands during a build,
+which may be disabled on some remote VMware Hypervisors.  Please consult
+the appropriate documentation on how to update VMware Hypervisor's firewall
+to allow these connections.
+
 To use a remote VMware vSphere Hypervisor to build your virtual machine,
 fill in the required `remote_*` configurations:
 
@@ -338,6 +385,13 @@ have to modify as well:
 * `remote_datastore` - The path to the datastore where the VM will be
   stored on the ESXi machine.
 
+* `remote_cache_datastore` - The path to the datastore where
+  supporting files will be stored during the build on the remote machine.
+
+* `remote_cache_directory` - The path where the ISO and/or floppy
+  files will be stored during the build on the remote machine. The path is
+  relative to the `remote_cache_datastore` on the remote machine.
+
 * `remote_username` - The SSH username used to access the remote machine.
 
 * `remote_password` - The SSH password for access to the remote machine.
diff --git a/website/source/docs/builders/vmware-vmx.html.markdown b/website/source/docs/builders/vmware-vmx.html.markdown
index 1fbbb3103..5cf752459 100644
--- a/website/source/docs/builders/vmware-vmx.html.markdown
+++ b/website/source/docs/builders/vmware-vmx.html.markdown
@@ -1,22 +1,24 @@
 ---
 layout: "docs"
 page_title: "VMware Builder from VMX"
+description: |-
+  This VMware Packer builder is able to create VMware virtual machines from an existing VMware virtual machine (a VMX file). It currently supports building virtual machines on hosts running VMware Fusion Professional for OS X, VMware Workstation for Linux and Windows, and VMware Player on Linux.
 ---
 
 # VMware Builder (from VMX)
 
 Type: `vmware-vmx`
 
-This VMware builder is able to create VMware virtual machines from an
+This VMware Packer builder is able to create VMware virtual machines from an
 existing VMware virtual machine (a VMX file). It currently
 supports building virtual machines on hosts running
-[VMware Fusion](http://www.vmware.com/products/fusion/overview.html) for OS X,
+[VMware Fusion Professional](http://www.vmware.com/products/fusion-professional/) for OS X,
 [VMware Workstation](http://www.vmware.com/products/workstation/overview.html)
 for Linux and Windows, and
 [VMware Player](http://www.vmware.com/products/player/) on Linux.
 
 The builder builds a virtual machine by cloning the VMX file using
-the clone capabilities introduced in VMware Fusion 6, Workstation 10,
+the clone capabilities introduced in VMware Fusion Professional 6, Workstation 10,
 and Player 6. After cloning the VM, it provisions software within the
 new machine, shuts it down, and compacts the disks. The resulting folder
 contains a new VMware virtual machine.
@@ -26,7 +28,7 @@ contains a new VMware virtual machine.
 Here is an example. This example is fully functional as long as the source
 path points to a real VMX file with the proper settings:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "vmware-vmx",
   "source_path": "/path/to/a/vm.vmx",
@@ -34,7 +36,7 @@ path points to a real VMX file with the proper settings:
   "ssh_password": "root",
   "shutdown_command": "shutdown -P now"
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -42,14 +44,21 @@ There are many configuration options available for the VMware builder.
 They are organized below into two categories: required and optional. Within
 each category, the available options are alphabetized and described.
 
-Required:
+### Required:
 
 * `source_path` (string) - Path to the source VMX file to clone.
 
 * `ssh_username` (string) - The username to use to SSH into the machine
   once the OS is installed.
 
-Optional:
+### Optional:
+
+* `boot_command` (array of strings) - This is an array of commands to type
+  when the virtual machine is firsted booted. The goal of these commands should
+  be to type just enough to initialize the operating system installer. Special
+  keys can be typed as well, and are covered in the section below on the boot
+  command. If this is not specified, it is assumed the installer will start
+  itself.
 
 * `boot_wait` (string) - The time to wait after booting the initial virtual
   machine before typing the `boot_command`. The value of this should be
@@ -57,24 +66,42 @@ Optional:
   five seconds and one minute 30 seconds, respectively. If this isn't specified,
   the default is 10 seconds.
 
-* `floppy_files` (array of strings) - A list of files to put onto a floppy
-  disk that is attached when the VM is booted for the first time. This is
-  most useful for unattended Windows installs, which look for an
-  `Autounattend.xml` file on removable media. By default no floppy will
-  be attached. The files listed in this configuration will all be put
-  into the root directory of the floppy disk; sub-directories are not supported.
+* `floppy_files` (array of strings) - A list of files to place onto a floppy
+  disk that is attached when the VM is booted. This is most useful
+  for unattended Windows installs, which look for an `Autounattend.xml` file
+  on removable media. By default, no floppy will be attached. All files
+  listed in this setting get placed into the root directory of the floppy
+  and the floppy is attached as the first floppy device. Currently, no
+  support exists for creating sub-directories on the floppy. Wildcard
+  characters (*, ?, and []) are allowed. Directory names are also allowed,
+  which will add all the files found in the directory to the floppy.
 
 * `fusion_app_path` (string) - Path to "VMware Fusion.app". By default this
   is "/Applications/VMware Fusion.app" but this setting allows you to
   customize this.
 
-* `headless` (bool) - Packer defaults to building VMware
+* `headless` (boolean) - Packer defaults to building VMware
   virtual machines by launching a GUI that shows the console of the
   machine being built. When this value is set to true, the machine will
   start without a console. For VMware machines, Packer will output VNC
   connection information in case you need to connect to the console to
   debug the build process.
 
+* `http_directory` (string) - Path to a directory to serve using an HTTP
+  server. The files in this directory will be available over HTTP that will
+  be requestable from the virtual machine. This is useful for hosting
+  kickstart files and so on. By default this is "", which means no HTTP
+  server will be started. The address and port of the HTTP server will be
+  available as variables in `boot_command`. This is covered in more detail
+  below.
+
+* `http_port_min` and `http_port_max` (integer) - These are the minimum and
+  maximum port to use for the HTTP server started to serve the `http_directory`.
+  Because Packer often runs in parallel, Packer will choose a randomly available
+  port in this range to run the HTTP server. If you want to force the HTTP
+  server to be on one port, make this minimum and maximum port the same.
+  By default the values are 8000 and 9000, respectively.
+
 * `output_directory` (string) - This is the path to the directory where the
   resulting virtual machine will be created. This may be relative or absolute.
   If relative, the path is relative to the working directory when `packer`
@@ -82,12 +109,6 @@ Optional:
   By default this is "output-BUILDNAME" where "BUILDNAME" is the name
   of the build.
 
-* `skip_compaction` (bool) -  VMware-created disks are defragmented
-  and compacted at the end of the build process using `vmware-vdiskmanager`.
-  In certain rare cases, this might actually end up making the resulting disks
-  slightly larger. If you find this to be the case, you can disable compaction
-  using this configuration value.
-
 * `shutdown_command` (string) - The command to use to gracefully shut down
   the machine once all the provisioning is done. By default this is an empty
   string, which tells Packer to just forcefully shut down the machine.
@@ -97,6 +118,12 @@ Optional:
   If it doesn't shut down in this time, it is an error. By default, the timeout
   is "5m", or five minutes.
 
+* `skip_compaction` (boolean) -  VMware-created disks are defragmented
+  and compacted at the end of the build process using `vmware-vdiskmanager`.
+  In certain rare cases, this might actually end up making the resulting disks
+  slightly larger. If you find this to be the case, you can disable compaction
+  using this configuration value.
+
 * `ssh_key_path` (string) - Path to a private key to use for authenticating
   with SSH. By default this is not set (key-based auth won't be used).
   The associated public key is expected to already be configured on the
@@ -105,10 +132,10 @@ Optional:
 * `ssh_password` (string) - The password for `ssh_username` to use to
   authenticate with SSH. By default this is the empty string.
 
-* `ssh_port` (int) - The port that SSH will listen on within the virtual
+* `ssh_port` (integer) - The port that SSH will listen on within the virtual
   machine. By default this is 22.
 
-* `ssh_skip_request_pty` (bool) - If true, a pty will not be requested as
+* `ssh_skip_request_pty` (boolean) - If true, a pty will not be requested as
   part of the SSH connection. By default, this is "false", so a pty
   _will_ be requested.
 
@@ -120,6 +147,16 @@ Optional:
   machine, without the file extension. By default this is "packer-BUILDNAME",
   where "BUILDNAME" is the name of the build.
 
-* `vmx_data` (object, string keys and string values) - Arbitrary key/values
+* `vmx_data` (object of key/value strings) - Arbitrary key/values
   to enter into the virtual machine VMX file. This is for advanced users
   who want to set properties such as memory, CPU, etc.
+
+* `vmx_data_post` (object of key/value strings) - Identical to `vmx_data`,
+  except that it is run after the virtual machine is shutdown, and before the
+  virtual machine is exported.
+
+* `vnc_port_min` and `vnc_port_max` (integer) - The minimum and maximum port to
+  use for VNC access to the virtual machine. The builder uses VNC to type
+  the initial `boot_command`. Because Packer generally runs in parallel, Packer
+  uses a randomly chosen port in this range that appears available. By default
+  this is 5900 to 6000. The minimum and maximum ports are inclusive.
diff --git a/website/source/docs/builders/vmware.html.markdown b/website/source/docs/builders/vmware.html.markdown
index c25172efc..84d94a369 100644
--- a/website/source/docs/builders/vmware.html.markdown
+++ b/website/source/docs/builders/vmware.html.markdown
@@ -1,11 +1,13 @@
 ---
 layout: "docs"
 page_title: "VMware Builder"
+description: |-
+  The VMware Packer builder is able to create VMware virtual machines for use with any VMware product.
 ---
 
 # VMware Builder
 
-The VMware builder is able to create VMware virtual machines for use
+The VMware Packer builder is able to create VMware virtual machines for use
 with any VMware product.
 
 Packer actually comes with multiple builders able to create VMware
diff --git a/website/source/docs/command-line/build.html.markdown b/website/source/docs/command-line/build.html.markdown
index 198bd85b4..bada564a1 100644
--- a/website/source/docs/command-line/build.html.markdown
+++ b/website/source/docs/command-line/build.html.markdown
@@ -1,33 +1,37 @@
 ---
 layout: "docs"
 page_title: "Build - Command-Line"
+description: |-
+  The `packer build` Packer command takes a template and runs all the builds within it in order to generate a set of artifacts. The various builds specified within a template are executed in parallel, unless otherwise specified. And the artifacts that are created will be outputted at the end of the build.
 ---
 
 # Command-Line: Build
 
-The `packer build` command takes a template and runs all the builds within
+The `packer build` Packer command takes a template and runs all the builds within
 it in order to generate a set of artifacts. The various builds specified within
 a template are executed in parallel, unless otherwise specified. And the
 artifacts that are created will be outputted at the end of the build.
 
 ## Options
 
+* `-color=false` - Disables colorized output. Enabled by default.
+
 * `-debug` - Disables parallelization and enables debug mode. Debug mode flags
   the builders that they should output debugging information. The exact behavior
   of debug mode is left to the builder. In general, builders usually will stop
   between each step, waiting for keyboard input before continuing. This will allow
   the user to inspect state and so on.
 
+* `-except=foo,bar,baz` - Builds all the builds except those with the given
+  comma-separated names. Build names by default are the names of their builders,
+  unless a specific `name` attribute is specified within the configuration.
+
 * `-force` - Forces a builder to run when artifacts from a previous build prevent
   a build from running. The exact behavior of a forced build is left to the builder.
   In general, a builder supporting the forced build will remove the artifacts from
   the previous build. This will allow the user to repeat a build without having to
   manually clean these artifacts beforehand.
 
-* `-except=foo,bar,baz` - Builds all the builds except those with the given
-  comma-separated names. Build names by default are the names of their builders,
-  unless a specific `name` attribute is specified within the configuration.
-
 * `-only=foo,bar,baz` - Only build the builds with the given comma-separated
   names. Build names by default are the names of their builders, unless a
   specific `name` attribute is specified within the configuration.
diff --git a/website/source/docs/command-line/fix.html.markdown b/website/source/docs/command-line/fix.html.markdown
index fa96f394c..958ebd0f8 100644
--- a/website/source/docs/command-line/fix.html.markdown
+++ b/website/source/docs/command-line/fix.html.markdown
@@ -1,11 +1,13 @@
 ---
 layout: "docs"
 page_title: "Fix - Command-Line"
+description: |-
+  The `packer fix` Packer command takes a template and finds backwards incompatible parts of it and brings it up to date so it can be used with the latest version of Packer. After you update to a new Packer release, you should run the fix command to make sure your templates work with the new release.
 ---
 
 # Command-Line: Fix
 
-The `packer fix` command takes a template and finds backwards incompatible
+The `packer fix` Packer command takes a template and finds backwards incompatible
 parts of it and brings it up to date so it can be used with the latest version
 of Packer. After you update to a new Packer release, you should run the
 fix command to make sure your templates work with the new release.
@@ -22,12 +24,10 @@ If fixing fails for any reason, the fix command will exit with a non-zero
 exit status. Error messages appear on standard error, so if you're redirecting
 output, you'll still see error messages.
 
-<div class="alert alert-block alert-info">
-<strong>Even when Packer fix doesn't do anything</strong> to the template,
+-> **Even when Packer fix doesn't do anything** to the template,
 the template will be outputted to standard out. Things such as configuration
 key ordering and indentation may be changed. The output format however, is
 pretty-printed for human readability.
-</div>
 
 The full list of fixes that the fix command performs is visible in the
 help output, which can be seen via `packer fix -h`.
diff --git a/website/source/docs/command-line/inspect.html.markdown b/website/source/docs/command-line/inspect.html.markdown
index dab659ac7..09f979208 100644
--- a/website/source/docs/command-line/inspect.html.markdown
+++ b/website/source/docs/command-line/inspect.html.markdown
@@ -1,11 +1,13 @@
 ---
 layout: "docs"
 page_title: "Inspect - Command-Line"
+description: |-
+  The `packer inspect` Packer command takes a template and outputs the various components a template defines. This can help you quickly learn about a template without having to dive into the JSON itself. The command will tell you things like what variables a template accepts, the builders it defines, the provisioners it defines and the order they'll run, and more.
 ---
 
 # Command-Line: Inspect
 
-The `packer inspect` command takes a template and outputs the various components
+The `packer inspect` Packer command takes a template and outputs the various components
 a template defines. This can help you quickly learn about a template without
 having to dive into the JSON itself.
 The command will tell you things like what variables a template accepts,
@@ -25,7 +27,7 @@ validate the syntax of your template by necessity.
 Given a basic template, here is an example of what the output might
 look like:
 
-```
+```text
 $ packer inspect template.json
 Variables and their defaults:
 
@@ -36,7 +38,7 @@ Builders:
 
   amazon-ebs
   amazon-instance
-  virtualbox
+  virtualbox-iso
 
 Provisioners:
 
diff --git a/website/source/docs/command-line/introduction.html.markdown b/website/source/docs/command-line/introduction.html.markdown
index fd4ada4d3..0a97e0056 100644
--- a/website/source/docs/command-line/introduction.html.markdown
+++ b/website/source/docs/command-line/introduction.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Packer Command-Line"
+description: |-
+  Packer is controlled using a command-line interface. All interaction with Packer is done via the `packer` tool. Like many other command-line tools, the `packer` tool takes a subcommand to execute, and that subcommand may have additional options as well. Subcommands are executed with `packer SUBCOMMAND`, where "SUBCOMMAND" is obviously the actual command you wish to execute.
 ---
 
 # Packer Command-Line
diff --git a/website/source/docs/command-line/machine-readable.html.markdown b/website/source/docs/command-line/machine-readable.html.markdown
index 1cdc06b4d..5fed33310 100644
--- a/website/source/docs/command-line/machine-readable.html.markdown
+++ b/website/source/docs/command-line/machine-readable.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "Machine-Readable Output - Command-Line"
+description: |-
+  By default, the output of Packer is very human-readable. It uses nice formatting, spacing, and colors in order to make Packer a pleasure to use. However, Packer was built with automation in mind. To that end, Packer supports a fully machine-readable output setting, allowing you to use Packer in automated environments.
 ---
 
 # Machine-Readable Output
@@ -22,7 +24,7 @@ all output to become machine-readable on stdout. Logging, if enabled,
 continues to appear on stderr. An example of the output is shown
 below:
 
-```
+```text
 $ packer -machine-readable version
 1376289459,,version,0.2.4
 1376289459,,version-prerelease,
@@ -43,7 +45,7 @@ Python.
 
 The format is:
 
-```
+```text
 timestamp,target,type,data...
 ```
 
diff --git a/website/source/docs/command-line/validate.html.markdown b/website/source/docs/command-line/validate.html.markdown
index e05c9410a..530f00295 100644
--- a/website/source/docs/command-line/validate.html.markdown
+++ b/website/source/docs/command-line/validate.html.markdown
@@ -1,18 +1,20 @@
 ---
 layout: "docs"
 page_title: "Validate - Command-Line"
+description: |-
+  The `packer validate` Packer command is used to validate the syntax and configuration of a template. The command will return a zero exit status on success, and a non-zero exit status on failure. Additionally, if a template doesn't validate, any error messages will be outputted.
 ---
 
 # Command-Line: Validate
 
-The `packer validate` command is used to validate the syntax and configuration
+The `packer validate` Packer command is used to validate the syntax and configuration
 of a [template](/docs/templates/introduction.html). The command will return
 a zero exit status on success, and a non-zero exit status on failure. Additionally,
 if a template doesn't validate, any error messages will be outputted.
 
 Example usage:
 
-```
+```text
 $ packer validate my-template.json
 Template validation failed. Errors are shown below.
 
diff --git a/website/source/docs/extend/builder.html.markdown b/website/source/docs/extend/builder.html.markdown
index f9fff68ee..a841d5c3d 100644
--- a/website/source/docs/extend/builder.html.markdown
+++ b/website/source/docs/extend/builder.html.markdown
@@ -1,11 +1,13 @@
 ---
 layout: "docs"
 page_title: "Custom Builder - Extend Packer"
+description: |-
+  Packer Builders are the components of Packer responsible for creating a machine, bringing it to a point where it can be provisioned, and then turning that provisioned machine into some sort of machine image. Several builders are officially distributed with Packer itself, such as the AMI builder, the VMware builder, etc. However, it is possible to write custom builders using the Packer plugin interface, and this page documents how to do that.
 ---
 
 # Custom Builder Development
 
-Builders are the components of Packer responsible for creating a machine,
+Packer Builders are the components of Packer responsible for creating a machine,
 bringing it to a point where it can be provisioned, and then turning
 that provisioned machine into some sort of machine image. Several builders
 are officially distributed with Packer itself, such as the AMI builder, the
@@ -15,11 +17,8 @@ the Packer plugin interface, and this page documents how to do that.
 Prior to reading this page, it is assumed you have read the page on
 [plugin development basics](/docs/extend/developing-plugins.html).
 
-<div class="alert alert-block">
-  <strong>Warning!</strong> This is an advanced topic. If you're new to Packer,
-  we recommend getting a bit more comfortable before you dive into writing
-  plugins.
-</div>
+~> **Warning!** This is an advanced topic. If you're new to Packer, we
+recommend getting a bit more comfortable before you dive into writing plugins.
 
 ## The Interface
 
@@ -28,13 +27,13 @@ interface. It is reproduced below for easy reference. The actual interface
 in the source code contains some basic documentation as well explaining
 what each method should do.
 
-<pre class="prettyprint">
+```go
 type Builder interface {
 	Prepare(...interface{}) error
 	Run(ui Ui, hook Hook, cache Cache) (Artifact, error)
 	Cancel()
 }
-</pre>
+```
 
 ### The "Prepare" Method
 
@@ -133,19 +132,17 @@ When the machine is ready to be provisioned, run the `packer.HookProvision`
 hook, making sure the communicator is not nil, since this is required for
 provisioners. An example of calling the hook is shown below:
 
-<pre class="prettyprint">
+```go
 hook.Run(packer.HookProvision, ui, comm, nil)
-</pre>
+```
 
 At this point, Packer will run the provisioners and no additional work
 is necessary.
 
-<div class="alert alert-info alert-block">
-<strong>Note:</strong> Hooks are still undergoing thought around their
+-> **Note:** Hooks are still undergoing thought around their
 general design and will likely change in a future version. They aren't
 fully "baked" yet, so they aren't documented here other than to tell you
 how to hook in provisioners.
-</div>
 
 ## Caching Files
 
diff --git a/website/source/docs/extend/command.html.markdown b/website/source/docs/extend/command.html.markdown
index 703b09547..d36a9087d 100644
--- a/website/source/docs/extend/command.html.markdown
+++ b/website/source/docs/extend/command.html.markdown
@@ -1,10 +1,13 @@
 ---
 layout: "docs"
+page_title: "Custom Command Development"
+description: |-
+  Packer Commands are the components of Packer that add functionality to the `packer` application. Packer comes with a set of commands out of the box, such as `build`. Commands are invoked as `packer <COMMAND>`. Custom commands allow you to add new commands to Packer to perhaps perform new functionality.
 ---
 
 # Custom Command Development
 
-Commands are the components of Packer that add functionality to the
+Packer Commands are the components of Packer that add functionality to the
 `packer` application. Packer comes with a set of commands out of the
 box, such as `build`. Commands are invoked as `packer <COMMAND>`.
 Custom commands allow you to add new commands to Packer to perhaps
@@ -19,11 +22,8 @@ over what keyword invokes the command with the `packer` binary. The keyword
 to invoke the command depends on how the plugin is installed and configured
 in the core Packer configuration.
 
-<div class="alert alert-block">
-  <strong>Warning!</strong> This is an advanced topic. If you're new to Packer,
-  we recommend getting a bit more comfortable before you dive into writing
-  plugins.
-</div>
+~> **Warning!** This is an advanced topic. If you're new to Packer, we
+recommend getting a bit more comfortable before you dive into writing plugins.
 
 ## The Interface
 
@@ -32,13 +32,13 @@ interface. It is reproduced below for easy reference. The actual interface
 in the source code contains some basic documentation as well explaining
 what each method should do.
 
-<pre class="prettyprint">
+```go
 type Command interface {
 	Help() string
 	Run(env Environment, args []string) int
 	Synopsis() string
 }
-</pre>
+```
 
 ### The "Help" Method
 
@@ -51,7 +51,7 @@ Packer commands generally follow the following format for help, but
 it is not required. You're allowed to make the help look like anything
 you please.
 
-```
+```text
 Usage: packer COMMAND [options] ARGS...
 
   Brief one or two sentence about the function of the command.
diff --git a/website/source/docs/extend/developing-plugins.html.markdown b/website/source/docs/extend/developing-plugins.html.markdown
index 1aa233e82..d67470930 100644
--- a/website/source/docs/extend/developing-plugins.html.markdown
+++ b/website/source/docs/extend/developing-plugins.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Developing Plugins"
+description: |-
+  This page will document how you can develop your own Packer plugins. Prior to reading this, it is assumed that you're comfortable with Packer and also know the basics of how Plugins work, from a user standpoint.
 ---
 
 # Developing Plugins
@@ -14,11 +17,8 @@ assumed that you're familiar with the language. This page will not be a
 Go language tutorial. Thankfully, if you are familiar with Go, the Go toolchain
 makes it extremely easy to develop Packer plugins.
 
-<div class="alert alert-block">
-  <strong>Warning!</strong> This is an advanced topic. If you're new to Packer,
-  we recommend getting a bit more comfortable before you dive into writing
-  plugins.
-</div>
+~> **Warning!** This is an advanced topic. If you're new to Packer, we
+recommend getting a bit more comfortable before you dive into writing plugins.
 
 ## Plugin System Architecture
 
@@ -67,7 +67,7 @@ There are two steps involved in creating a plugin:
 A basic example is shown below. In this example, assume the `Builder` struct
 implements the `packer.Builder` interface:
 
-<pre class="prettyprint">
+```go
 import (
   "github.com/mitchellh/packer/plugin"
 )
@@ -78,7 +78,7 @@ type Builder struct{}
 func main() {
 	plugin.ServeBuilder(new(Builder))
 }
-</pre>
+```
 
 **That's it!** `plugin.ServeBuilder` handles all the nitty gritty of
 communicating with Packer core and serving your builder over RPC. It
@@ -91,14 +91,12 @@ installed using standard installation procedures.
 The specifics of how to implement each type of interface are covered
 in the relevant subsections available in the navigation to the left.
 
-<div class="alert alert-warn alert-block">
-<strong>Lock your dependencies.</strong> Unfortunately, Go's dependency
+~> **Lock your dependencies!** Unfortunately, Go's dependency
 management story is fairly sad. There are various unofficial methods out
 there for locking dependencies, and using one of them is highly recomended
 since the Packer codebase will continue to improve, potentially breaking
 APIs along the way until there is a stable release. By locking your dependencies,
 your plugins will continue to work with the version of Packer you lock to.
-</div>
 
 ## Logging and Debugging
 
@@ -111,7 +109,7 @@ Packer will prefix any logs from plugins with the path to that plugin
 to make it identifiable where the logs come from. Some example logs are
 shown below:
 
-```
+```text
 2013/06/10 21:44:43 ui: Available commands are:
 2013/06/10 21:44:43 Loading command: build
 2013/06/10 21:44:43 packer-command-build: 2013/06/10 21:44:43 Plugin minimum port: 10000
@@ -143,13 +141,13 @@ While developing plugins, you can configure your Packer configuration
 to point directly to the compiled plugin in order to test it. For example,
 building the CustomCloud plugin, I may configure packer like so:
 
-<pre class="prettyprint">
+```javascript
 {
   "builders": {
     "custom-cloud": "/an/absolute/path/to/packer-builder-custom-cloud"
   }
 }
-</pre>
+```
 
 This would configure Packer to have the "custom-cloud" plugin, and execute
 the binary that I am building during development. This is extremely useful
diff --git a/website/source/docs/extend/plugins.html.markdown b/website/source/docs/extend/plugins.html.markdown
index fe1dd82e1..12db22150 100644
--- a/website/source/docs/extend/plugins.html.markdown
+++ b/website/source/docs/extend/plugins.html.markdown
@@ -1,11 +1,13 @@
 ---
 layout: "docs"
 page_title: "Packer Plugins - Extend Packer"
+description: |-
+  Packer Plugins allow new functionality to be added to Packer without modifying the core source code. Packer plugins are able to add new commands, builders, provisioners, hooks, and more. In fact, much of Packer itself is implemented by writing plugins that are simply distributed with Packer. For example, all the commands, builders, provisioners, and more that ship with Packer are implemented as Plugins that are simply hardcoded to load with Packer.
 ---
 
 # Packer Plugins
 
-Plugins allow new functionality to be added to Packer without
+Packer Plugins allow new functionality to be added to Packer without
 modifying the core source code. Packer plugins are able to add new
 commands, builders, provisioners, hooks, and more. In fact, much of Packer
 itself is implemented by writing plugins that are simply distributed with
@@ -36,43 +38,31 @@ applications running.
 
 ## Installing Plugins
 
-Plugins are installed by modifying the [core Packer configuration](/docs/other/core-configuration.html). Within
-the core configuration, each component has a key/value mapping of the
-plugin name to the actual plugin binary.
+The easiest way to install a plugin is to name it correctly, then place
+it in the proper directory. To name a plugin correctly, make sure the
+binary is named `packer-TYPE-NAME`. For example, `packer-builder-amazon-ebs`
+for a "builder" type plugin named "amazon-ebs". Valid types for plugins
+are down this page more.
 
-For example, if we're adding a new builder for CustomCloud, the core
-Packer configuration may look like this:
+Once the plugin is named properly, Packer automatically discovers plugins
+in the following directories in the given order. If a conflicting plugin is
+found later, it will take precedence over one found earlier.
 
-<pre class="prettyprint">
-{
-  "builders": {
-    "custom-cloud": "packer-builder-custom-cloud"
-  }
-}
-</pre>
+1. The directory where `packer` is, or the executable directory.
 
-In this case, the "custom-cloud" type is the type that is actually used for the value
-of the "type" configuration key for the builder definition.
+2. `~/.packer.d/plugins` on Unix systems or `%APPDATA%/packer.d` on
+     Windows.
 
-The value, "packer-builder-custom-cloud", is the path to the plugin binary.
-It can be an absolute or relative path. If it is not an absolute path, then
-the binary is searched for on the PATH. In the example above, Packer will
-search for `packer-builder-custom-cloud` on the PATH.
+3. The current working directory.
 
-After adding the plugin to the core Packer configuration, it is immediately
-available on the next run of Packer. To uninstall a plugin, just remove it
-from the core Packer configuration.
+The valid types for plugins are:
 
-In addition to builders, other types of plugins can be installed. The full
-list is below:
+* `builder` - Plugins responsible for building images for a specific platform.
 
-* `builders` - A key/value pair of builder type to the builder plugin
-  application.
+* `command` - A CLI sub-command for `packer`.
 
-* `commands` - A key/value pair of the command name to the command plugin
-  application. The command name is what is executed on the command line, like
-  `packer COMMAND`.
+* `post-processor` - A post-processor responsible for taking an artifact
+    from a builder and turning it into something else.
 
-* `provisioners` - A key/value pair of the provisioner type to the
-  provisioner plugin application. The provisioner type is the value of the
-  "type" configuration used within templates.
+* `provisioner` - A provisioner to install software on images created by
+    a builder.
diff --git a/website/source/docs/extend/post-processor.html.markdown b/website/source/docs/extend/post-processor.html.markdown
index b453dda29..204cc593b 100644
--- a/website/source/docs/extend/post-processor.html.markdown
+++ b/website/source/docs/extend/post-processor.html.markdown
@@ -1,10 +1,13 @@
 ---
 layout: "docs"
+page_title: "Custom Post-Processor Development"
+description: |-
+  Packer  Post-processors are the components of Packer that transform one artifact into another, for example by compressing files, or uploading them.
 ---
 
 # Custom Post-Processor Development
 
-Post-processors are the components of Packer that transform one artifact
+Packer Post-processors are the components of Packer that transform one artifact
 into another, for example by compressing files, or uploading them.
 
 In the compression example, the transformation would be taking an artifact
@@ -20,11 +23,8 @@ Prior to reading this page, it is assumed you have read the page on
 Post-processor plugins implement the `packer.PostProcessor` interface and
 are served using the `plugin.ServePostProcessor` function.
 
-<div class="alert alert-block">
-  <strong>Warning!</strong> This is an advanced topic. If you're new to Packer,
-  we recommend getting a bit more comfortable before you dive into writing
-  plugins.
-</div>
+~> **Warning!** This is an advanced topic. If you're new to Packer, we
+recommend getting a bit more comfortable before you dive into writing plugins.
 
 
 ## The Interface
@@ -34,13 +34,12 @@ The interface that must be implemented for a post-processor is the
 The actual interface in the source code contains some basic documentation as well explaining
 what each method should do.
 
-
-<pre class="prettyprint">
+```go
 type PostProcessor interface {
 	Configure(interface{}) error
 	PostProcess(Ui, Artifact) (a Artifact, keep bool, err error)
 }
-</pre>
+```
 
 ### The "Configure" Method
 
diff --git a/website/source/docs/extend/provisioner.html.markdown b/website/source/docs/extend/provisioner.html.markdown
index bf6628b87..cb73cccd2 100644
--- a/website/source/docs/extend/provisioner.html.markdown
+++ b/website/source/docs/extend/provisioner.html.markdown
@@ -1,10 +1,13 @@
 ---
 layout: "docs"
+page_title: "Custom Provisioner Development"
+description: |-
+  Packer Provisioners are the components of Packer that install and configure software into a running machine prior to turning that machine into an image. An example of a provisioner is the shell provisioner, which runs shell scripts within the machines.
 ---
 
 # Custom Provisioner Development
 
-Provisioners are the components of Packer that install and configure
+Packer Provisioners are the components of Packer that install and configure
 software into a running machine prior to turning that machine into an
 image. An example of a provisioner is the [shell provisioner](/docs/provisioners/shell.html),
 which runs shell scripts within the machines.
@@ -15,12 +18,8 @@ Prior to reading this page, it is assumed you have read the page on
 Provisioner plugins implement the `packer.Provisioner` interface and
 are served using the `plugin.ServeProvisioner` function.
 
-<div class="alert alert-block">
-  <strong>Warning!</strong> This is an advanced topic. If you're new to Packer,
-  we recommend getting a bit more comfortable before you dive into writing
-  plugins.
-</div>
-
+~> **Warning!** This is an advanced topic. If you're new to Packer, we
+recommend getting a bit more comfortable before you dive into writing plugins.
 
 ## The Interface
 
@@ -29,13 +28,12 @@ The interface that must be implemented for a provisioner is the
 The actual interface in the source code contains some basic documentation as well explaining
 what each method should do.
 
-
-<pre class="prettyprint">
+```go
 type Provisioner interface {
 	Prepare(...interface{}) error
 	Provision(Ui, Communicator) error
 }
-</pre>
+```
 
 ### The "Prepare" Method
 
@@ -86,7 +84,7 @@ The documentation around the [code itself](https://github.com/mitchellh/packer/b
 is really great as an overview of how to use the interface. You should begin
 by reading this. Once you have read it, you can see some example usage below:
 
-<pre class="prettyprint">
+```go
 // Build the remote command.
 var cmd packer.RemoteCmd
 cmd.Command = "echo foo"
@@ -106,4 +104,4 @@ cmd.Wait()
 
 // Read the stdout!
 fmt.Printf("Command output: %s", stdout.String())
-</pre>
+```
diff --git a/website/source/docs/index.html.markdown b/website/source/docs/index.html.markdown
index 2996da011..5894d17db 100644
--- a/website/source/docs/index.html.markdown
+++ b/website/source/docs/index.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Packer Documentation"
+description: |-
+  Welcome to the Packer documentation! This documentation is more of a reference guide for all available features and options in Packer. If you're just getting started with Packer, please start with the introduction and getting started guide instead.
 ---
 
 # Packer Documentation
diff --git a/website/source/docs/installation.html.markdown b/website/source/docs/installation.html.markdown
index 32fde782f..c0aee9528 100644
--- a/website/source/docs/installation.html.markdown
+++ b/website/source/docs/installation.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "Install Packer"
+description: |-
+  Packer must first be installed on the machine you want to run it on. To make installation easy, Packer is distributed as a binary package for all supported platforms and architectures. This page will not cover how to compile Packer from source, as that is covered in the README and is only recommended for advanced users.
 ---
 
 # Install Packer
@@ -36,13 +38,13 @@ contains instructions for setting the PATH on Windows.
 After installing Packer, verify the installation worked by opening
 a new command prompt or console, and checking that `packer` is available:
 
-```
+```text
 $ packer
 usage: packer [--version] [--help] <command> [<args>]
 
 Available commands are:
     build        build image(s) from template
-    fix           fixes templates from old versions of packer
+    fix          fixes templates from old versions of packer
     inspect      see components of a template
     validate     check that a template is valid
 ```
@@ -67,7 +69,7 @@ If you're using OS X and [Homebrew](http://brew.sh), you can install Packer by
 adding the `binary` tap. Remember that this is updated by a 3rd party, so
 it may not be the latest available version.
 
-```
+```text
 $ brew tap homebrew/binary
 $ brew install packer
 ```
diff --git a/website/source/docs/machine-readable/command-build.html.markdown b/website/source/docs/machine-readable/command-build.html.markdown
index aac2713f9..836a61ef2 100644
--- a/website/source/docs/machine-readable/command-build.html.markdown
+++ b/website/source/docs/machine-readable/command-build.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs_machine_readable"
 page_title: "Command: build - Machine-Readable Reference"
+description: |-
+  These are the machine-readable types that exist as part of the output of `packer build`.
 ---
 
 # Build Command Types
diff --git a/website/source/docs/machine-readable/command-inspect.html.markdown b/website/source/docs/machine-readable/command-inspect.html.markdown
index 3d24c884d..3f8bbb852 100644
--- a/website/source/docs/machine-readable/command-inspect.html.markdown
+++ b/website/source/docs/machine-readable/command-inspect.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs_machine_readable"
 page_title: "Command: inspect - Machine-Readable Reference"
+description: |-
+  These are the machine-readable types that exist as part of the output of `packer inspect`.
 ---
 
 # Inspect Command Types
diff --git a/website/source/docs/machine-readable/command-version.html.markdown b/website/source/docs/machine-readable/command-version.html.markdown
index a84a49762..a7029b627 100644
--- a/website/source/docs/machine-readable/command-version.html.markdown
+++ b/website/source/docs/machine-readable/command-version.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs_machine_readable"
 page_title: "Command: version - Machine-Readable Reference"
+description: |-
+  These are the machine-readable types that exist as part of the output of `packer version`.
 ---
 
 # Version Command Types
diff --git a/website/source/docs/machine-readable/general.html.markdown b/website/source/docs/machine-readable/general.html.markdown
index 8f604e56e..05eb2699a 100644
--- a/website/source/docs/machine-readable/general.html.markdown
+++ b/website/source/docs/machine-readable/general.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs_machine_readable"
 page_title: "General Types - Machine-Readable Reference"
+description: |-
+  These are the machine-readable types that can appear in almost any machine-readable output and are provided by Packer core itself.
 ---
 
 # General Types
diff --git a/website/source/docs/machine-readable/index.html.markdown b/website/source/docs/machine-readable/index.html.markdown
index f0ac3e112..d26106b15 100644
--- a/website/source/docs/machine-readable/index.html.markdown
+++ b/website/source/docs/machine-readable/index.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs_machine_readable"
 page_title: "Machine-Readable Reference"
+description: |-
+  This is the reference for the various message categories for Packer machine-readable output. Please read that page if you're unfamiliar with the general format and usage for the machine-readable output.
 ---
 
 # Machine-Readable Reference
diff --git a/website/source/docs/other/core-configuration.html.markdown b/website/source/docs/other/core-configuration.html.markdown
index 8592b2e08..3727af061 100644
--- a/website/source/docs/other/core-configuration.html.markdown
+++ b/website/source/docs/other/core-configuration.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Core Configuration"
+description: |-
+  There are a few configuration settings that affect Packer globally by configuring the core of Packer. These settings all have reasonable defaults, so you generally don't have to worry about it until you want to tweak a configuration. If you're just getting started with Packer, don't worry about core configuration for now.
 ---
 
 # Core Configuration
@@ -25,7 +28,7 @@ The format of the configuration file is basic JSON.
 Below is the list of all available configuration parameters for the core
 configuration file. None of these are required, since all have sane defaults.
 
-* `plugin_min_port` and `plugin_max_port` (int) - These are the minimum and
+* `plugin_min_port` and `plugin_max_port` (integer) - These are the minimum and
   maximum ports that Packer uses for communication with plugins, since
   plugin communication happens over TCP connections on your local host.
   By default these are 10,000 and 25,000, respectively. Be sure to set a fairly
diff --git a/website/source/docs/other/debugging.html.markdown b/website/source/docs/other/debugging.html.markdown
index 9513e463c..714a87264 100644
--- a/website/source/docs/other/debugging.html.markdown
+++ b/website/source/docs/other/debugging.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Debugging Packer"
+description: |-
+  Packer strives to be stable and bug-free, but issues inevitably arise where certain things may not work entirely correctly, or may not appear to work correctly. In these cases, it is sometimes helpful to see more details about what Packer is actually doing.
 ---
 
 # Debugging Packer
diff --git a/website/source/docs/other/environmental-variables.html.markdown b/website/source/docs/other/environmental-variables.html.markdown
new file mode 100644
index 000000000..318e25e25
--- /dev/null
+++ b/website/source/docs/other/environmental-variables.html.markdown
@@ -0,0 +1,34 @@
+---
+layout: "docs"
+page_title: "Environmental Variables for Packer"
+description: |-
+  Packer uses a variety of environmental variables.
+---
+
+# Environmental Variables for Packer
+
+Packer uses a variety of environmental variables. A listing and description of each can be found below:
+
+* `PACKER_CACHE_DIR` - The location of the packer cache.
+
+* `PACKER_CONFIG` - The location of the core configuration file. The format
+     of the configuration file is basic JSON.
+     See the [core configuration page](/docs/other/core-configuration.html).
+
+* `PACKER_LOG` - Setting this to any value will enable the logger.
+     See the [debugging page](/docs/other/debugging.html).
+
+* `PACKER_LOG_PATH` - The location of the log file. Note: `PACKER_LOG` must
+     be set for any logging to occur. See the [debugging page](/docs/other/debugging.html).
+
+* `PACKER_NO_COLOR` - Setting this to any value will disable color in the terminal.
+
+* `PACKER_PLUGIN_MAX_PORT` - The maximum port that Packer uses for
+     communication with plugins, since plugin communication happens over
+     TCP connections on your local host. The default is 25,000.
+     See the [core configuration page](/docs/other/core-configuration.html).
+
+* `PACKER_PLUGIN_MIN_PORT` - The minimum port that Packer uses for
+     communication with plugins, since plugin communication happens
+     over TCP connections on your local host. The default is 10,000.
+     See the [core configuration page](/docs/other/core-configuration.html).
diff --git a/website/source/docs/post-processors/compress.html.markdown b/website/source/docs/post-processors/compress.html.markdown
new file mode 100644
index 000000000..ea3b9c7ac
--- /dev/null
+++ b/website/source/docs/post-processors/compress.html.markdown
@@ -0,0 +1,31 @@
+---
+layout: "docs"
+page_title: "compress Post-Processor"
+description: |-
+  The Packer compress post-processor takes an artifact with files (such as from VMware or VirtualBox) and gzip compresses the artifact into a single archive.
+---
+
+# Compress Post-Processor
+
+Type: `compress`
+
+The Packer compress post-processor takes an artifact with files (such as from
+VMware or VirtualBox) and gzip compresses the artifact into a single
+archive.
+
+## Configuration
+
+The configuration for this post-processor is extremely simple.
+
+* `output` (string) - The path to save the compressed archive.
+
+## Example
+
+An example is shown below, showing only the post-processor configuration:
+
+```javascript
+{
+  "type": "compress",
+  "output": "foo.tar.gz"
+}
+```
diff --git a/website/source/docs/post-processors/docker-import.html.markdown b/website/source/docs/post-processors/docker-import.html.markdown
index e2ca3c93b..c2d7bba80 100644
--- a/website/source/docs/post-processors/docker-import.html.markdown
+++ b/website/source/docs/post-processors/docker-import.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "docker-import Post-Processor"
+description: |-
+  The Packer Docker import post-processor takes an artifact from the docker builder and imports it with Docker locally. This allows you to apply a repository and tag to the image and lets you use the other Docker post-processors such as docker-push to push the image to a registry.
 ---
 
 # Docker Import Post-Processor
 
 Type: `docker-import`
 
-The Docker import post-processor takes an artifact from the
+The Packer Docker import post-processor takes an artifact from the
 [docker builder](/docs/builders/docker.html) and imports it with Docker
 locally. This allows you to apply a repository and tag to the image
 and lets you use the other Docker post-processors such as
@@ -17,7 +19,7 @@ to a registry.
 ## Configuration
 
 The configuration for this post-processor is extremely simple. At least
-a repository is required. The tag is optional.
+a repository is required.
 
 * `repository` (string) - The repository of the imported image.
 
@@ -28,13 +30,13 @@ a repository is required. The tag is optional.
 
 An example is shown below, showing only the post-processor configuration:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "docker-import",
   "repository": "mitchellh/packer",
   "tag": "0.7"
 }
-</pre>
+```
 
 This example would take the image created by the Docker builder
 and import it into the local Docker process with a name of `mitchellh/packer:0.7`.
diff --git a/website/source/docs/post-processors/docker-push.html.markdown b/website/source/docs/post-processors/docker-push.html.markdown
index 602e126e0..2f7ae3e92 100644
--- a/website/source/docs/post-processors/docker-push.html.markdown
+++ b/website/source/docs/post-processors/docker-push.html.markdown
@@ -1,26 +1,36 @@
 ---
 layout: "docs"
 page_title: "Docker Push Post-Processor"
+description: |-
+  The Packer Docker push post-processor takes an artifact from the docker-import post-processor and pushes it to a Docker registry.
 ---
 
 # Docker Push Post-Processor
 
 Type: `docker-push`
 
-The Docker push post-processor takes an artifact from the
+The Packer Docker push post-processor takes an artifact from the
 [docker-import](/docs/post-processors/docker-import.html) post-processor
 and pushes it to a Docker registry.
 
-<div class="alert alert-info alert-block">
-<strong>Before you use this,</strong> you must manually <code>docker login</code>
-to the proper repository. A future version of Packer will automate this
-for you, but for now you must manually do this.
-</div>
-
 ## Configuration
 
-This post-processor has no configuration! Simply add it to your chain
-of post-processors and the image will be uploaded.
+This post-processor has only optional configuration:
+
+* `login` (boolean) - Defaults to false. If true, the post-processor will
+    login prior to pushing.
+
+* `login_email` (string) - The email to use to authenticate to login.
+
+* `login_username` (string) - The username to use to authenticate to login.
+
+* `login_password` (string) - The password to use to authenticate to login.
+
+* `login_server` (string) - The server address to login to.
+
+-> **Note:** If you login using the credentials above, the
+post-processor will automatically log you out afterwards (just the server
+specified).
 
 ## Example
 
diff --git a/website/source/docs/post-processors/docker-save.html.markdown b/website/source/docs/post-processors/docker-save.html.markdown
new file mode 100644
index 000000000..ca03dfcf6
--- /dev/null
+++ b/website/source/docs/post-processors/docker-save.html.markdown
@@ -0,0 +1,37 @@
+---
+layout: "docs"
+page_title: "docker-save Post-Processor"
+description: |-
+  The Packer Docker Save post-processor takes an artifact from the docker builder that was committed and saves it to a file. This is similar to exporting the Docker image directly from the builder, except that it preserves the hierarchy of images and metadata.
+---
+
+# Docker Save Post-Processor
+
+Type: `docker-save`
+
+The Packer Docker Save post-processor takes an artifact from the
+[docker builder](/docs/builders/docker.html) that was committed
+and saves it to a file. This is similar to exporting the Docker image
+directly from the builder, except that it preserves the hierarchy of
+images and metadata.
+
+We understand the terminology can be a bit confusing, but we've
+adopted the terminology from Docker, so if you're familiar with that, then
+you'll be familiar with this and vice versa.
+
+## Configuration
+
+The configuration for this post-processor is extremely simple.
+
+* `path` (string) - The path to save the image.
+
+## Example
+
+An example is shown below, showing only the post-processor configuration:
+
+```javascript
+{
+  "type": "docker-save",
+  "path": "foo.tar"
+}
+```
diff --git a/website/source/docs/post-processors/docker-tag.html.markdown b/website/source/docs/post-processors/docker-tag.html.markdown
new file mode 100644
index 000000000..7b8b92722
--- /dev/null
+++ b/website/source/docs/post-processors/docker-tag.html.markdown
@@ -0,0 +1,50 @@
+---
+layout: "docs"
+page_title: "docker-tag Post-Processor"
+description: |-
+  The Packer Docker Tag post-processor takes an artifact from the docker builder that was committed and tags it into a repository. This allows you to use the other Docker post-processors such as docker-push to push the image to a registry.
+---
+
+# Docker Tag Post-Processor
+
+Type: `docker-tag`
+
+The Packer Docker Tag post-processor takes an artifact from the
+[docker builder](/docs/builders/docker.html) that was committed
+and tags it into a repository. This allows you to use the other
+Docker post-processors such as
+[docker-push](/docs/post-processors/docker-push.html) to push the image
+to a registry.
+
+This is very similar to the [docker-import](/docs/post-processors/docker-import.html)
+post-processor except that this works with committed resources, rather
+than exported.
+
+## Configuration
+
+The configuration for this post-processor is extremely simple. At least
+a repository is required.
+
+* `repository` (string) - The repository of the image.
+
+* `tag` (string) - The tag for the image. By default this is not
+  set.
+
+## Example
+
+An example is shown below, showing only the post-processor configuration:
+
+```javascript
+{
+  "type": "docker-tag",
+  "repository": "mitchellh/packer",
+  "tag": "0.7"
+}
+```
+
+This example would take the image created by the Docker builder
+and tag it into the local Docker process with a name of `mitchellh/packer:0.7`.
+
+Following this, you can use the
+[docker-push](/docs/post-processors/docker-push.html)
+post-processor to push it to a registry, if you want.
diff --git a/website/source/docs/post-processors/vagrant-cloud.html.markdown b/website/source/docs/post-processors/vagrant-cloud.html.markdown
new file mode 100644
index 000000000..0963618a5
--- /dev/null
+++ b/website/source/docs/post-processors/vagrant-cloud.html.markdown
@@ -0,0 +1,108 @@
+---
+layout: "docs"
+page_title: "Vagrant Cloud Post-Processor"
+description: |-
+  The Packer Vagrant Cloud post-processor receives a Vagrant box from the `vagrant` post-processor and pushes it to Vagrant Cloud. Vagrant Cloud hosts and serves boxes to Vagrant, allowing you to version and distribute boxes to an organization in a simple way.
+---
+
+# Vagrant Cloud Post-Processor
+
+Type: `vagrant-cloud`
+
+The Packer Vagrant Cloud post-processor receives a Vagrant box from the `vagrant`
+post-processor and pushes it to Vagrant Cloud. [Vagrant Cloud](https://vagrantcloud.com)
+hosts and serves boxes to Vagrant, allowing you to version and distribute
+boxes to an organization in a simple way.
+
+You'll need to be familiar with Vagrant Cloud, have an upgraded account
+to enable box hosting, and be distributing your box via the [shorthand name](http://docs.vagrantup.com/v2/cli/box.html)
+configuration.
+
+## Workflow
+
+It's important to understand the workflow that using this post-processor
+enforces in order to take full advantage of Vagrant and Vagrant Cloud.
+
+The use of this processor assume that you currently distribute, or plan
+to distrubute, boxes via Vagrant Cloud. It also assumes you create Vagrant
+Boxes and deliver them to your team in some fashion.
+
+Here is an example workflow:
+
+1. You use Packer to build a Vagrant Box for the `virtualbox` provider
+2. The `vagrant-cloud` post-processor is configured to point to the box `hashicorp/foobar` on Vagrant Cloud
+via the `box_tag` configuration
+2. The post-processor receives the box from the `vagrant` post-processor
+3. It then creates the configured version, or verifies the existence of it, on Vagrant Cloud
+4. A provider matching the name of the Vagrant provider is then created
+5. The box is uploaded to Vagrant Cloud
+6. The upload is verified
+7. The version is released and available to users of the box
+
+
+## Configuration
+
+The configuration allows you to specify the target box that you have
+access to on Vagrant Cloud, as well as authentication and version information.
+
+### Required:
+
+* `access_token` (string) - Your access token for the Vagrant Cloud API.
+  This can be generated on your [tokens page](https://vagrantcloud.com/account/tokens).
+
+* `box_tag` (string) - The shorthand tag for your box that maps to
+   Vagrant Cloud, i.e `hashicorp/precise64` for `vagrantcloud.com/hashicorp/precise64`
+
+* `version` (string) - The version number, typically incrementing a previous version.
+  The version string is validated based on [Semantic Versioning](http://semver.org/). The string must match
+  a pattern that could be semver, and doesn't validate that the version comes after
+  your previous versions.
+
+
+### Optional:
+
+* `no_release` (string) - If set to true, does not release the version
+on Vagrant Cloud, making it active. You can manually release the version
+via the API or Web UI. Defaults to false.
+
+* `vagrant_cloud_url` (string) - Override the base URL for Vagrant Cloud. This
+is useful if you're using Vagrant Private Cloud in your own network. Defaults
+to `https://vagrantcloud.com/api/v1`
+
+* `version_description` (string) - Optionally markdown text used as a full-length
+  and in-depth description of the version, typically for denoting changes introduced
+
+* `box_download_url` (string) - Optional URL for a self-hosted box. If this is set
+the box will not be uploaded to the Vagrant Cloud.
+
+## Use with Vagrant Post-Processor
+
+You'll need to use the Vagrant post-processor before using this post-processor.
+An example configuration is below. Note the use of the array specifying
+the execution order.
+
+```javascript
+{
+    "variables": {
+        "version": "",
+        "cloud_token": ""
+    },
+    "builders": [{
+      // ...
+    }],
+    "post-processors": [
+      [{
+          "type": "vagrant",
+          "include": ["image.iso"],
+          "vagrantfile_template": "vagrantfile.tpl",
+          "output": "proxycore_{{.Provider}}.box"
+      },
+      {
+          "type": "vagrant-cloud",
+          "box_tag": "hashicorp/precise64",
+          "access_token": "{{user `cloud_token`}}",
+          "version": "{{user `version`}}"
+      }]
+    ]
+}
+```
diff --git a/website/source/docs/post-processors/vagrant.html.markdown b/website/source/docs/post-processors/vagrant.html.markdown
index 204f235d0..d5be196a6 100644
--- a/website/source/docs/post-processors/vagrant.html.markdown
+++ b/website/source/docs/post-processors/vagrant.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Vagrant Post-Processor"
+description: |-
+  The Packer Vagrant post-processor takes a build and converts the artifact into a valid Vagrant box, if it can. This lets you use Packer to automatically create arbitrarily complex Vagrant boxes, and is in fact how the official boxes distributed by Vagrant are created.
 ---
 
 # Vagrant Post-Processor
 
 Type: `vagrant`
 
-The Vagrant post-processor takes a build and converts the artifact
+The Packer Vagrant post-processor takes a build and converts the artifact
 into a valid [Vagrant](http://www.vagrantup.com) box, if it can.
 This lets you use Packer to automatically create arbitrarily complex
 Vagrant boxes, and is in fact how the official boxes distributed by
@@ -28,14 +30,15 @@ providers.
 
 * AWS
 * DigitalOcean
+* Hyper-V
+* Parallels
+* QEMU
 * VirtualBox
 * VMware
 
-<div class="alert alert-block alert-info">
-<strong>Support for additional providers</strong> is planned. If the
+-> **Support for additional providers** is planned. If the
 Vagrant post-processor doesn't support creating boxes for a provider you
 care about, please help by contributing to Packer and adding support for it.
-</div>
 
 ## Configuration
 
@@ -51,13 +54,16 @@ below, with more details about certain options in following sections.
 * `compression_level` (integer) - An integer repesenting the
   compression level to use when creating the Vagrant box.  Valid
   values range from 0 to 9, with 0 being no compression and 9 being
-  the best compression. By default, compression is enabled at level 1.
+  the best compression. By default, compression is enabled at level 6.
 
 * `include` (array of strings) - Paths to files to include in the
   Vagrant box. These files will each be copied into the top level directory
   of the Vagrant box (regardless of their paths). They can then be used
   from the Vagrantfile.
 
+* `keep_input_artifact` (boolean) - If set to true, do not delete the
+  `output_directory` on a successful build. Defaults to false.
+
 * `output` (string) - The full path to the box file that will be created
   by this post-processor. This is a
   [configuration template](/docs/templates/configuration-templates.html).
@@ -79,16 +85,15 @@ The post-processor lets you do this.
 
 Specify overrides within the `override` configuration by provider name:
 
-```json
+```javascript
 {
-    "type": "vagrant",
-
-    "compression_level": 1,
-    "override": {
-        "vmware": {
-            "compression_level": 0
-        }
+  "type": "vagrant",
+  "compression_level": 1,
+  "override": {
+    "vmware": {
+      "compression_level": 0
     }
+  }
 }
 ```
 
@@ -96,7 +101,7 @@ In the example above, the compression level will be set to 1 except for
 VMware, where it will be set to 0.
 
 The available provider names are: `aws`, `digitalocean`, `virtualbox`,
-and `vmware`.
+`vmware`, and `parallels`.
 
 ## Input Artifacts
 
diff --git a/website/source/docs/post-processors/vsphere.html.markdown b/website/source/docs/post-processors/vsphere.html.markdown
index 742568dbe..3ce8ec5f9 100644
--- a/website/source/docs/post-processors/vsphere.html.markdown
+++ b/website/source/docs/post-processors/vsphere.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "vSphere Post-Processor"
+description: |-
+  The Packer vSphere post-processor takes an artifact from the VMware builder and uploads it to a vSphere endpoint.
 ---
 
 # vSphere Post-Processor
 
 Type: `vsphere`
 
-The vSphere post-processor takes an artifact from the VMware builder
+The Packer vSphere post-processor takes an artifact from the VMware builder
 and uploads it to a vSphere endpoint.
 
 ## Configuration
@@ -23,8 +25,6 @@ Required:
 * `datacenter` (string) - The name of the datacenter within vSphere to
   add the VM to.
 
-* `datastore` (string) - The name of the datastore to store this VM.
-
 * `host` (string) - The vSphere host that will be contacted to perform
   the VM upload.
 
@@ -36,17 +36,19 @@ Required:
 * `username` (string) - The username to use to authenticate to the vSphere
   endpoint.
 
-* `vm_folder` (string) - The folder within the datastore to store the VM.
-
 * `vm_name` (string) - The name of the VM once it is uploaded.
 
-* `vm_network` (string) - The name of the VM network this VM will be
-  added to.
-
 Optional:
 
+* `datastore` (string) - The name of the datastore to store this VM.
+
 * `disk_mode` (string) - Target disk format. See `ovftool` manual for
   available options. By default, "thick" will be used.
 
-* `insecure` (bool) - Whether or not the connection to vSphere can be done
+* `insecure` (boolean) - Whether or not the connection to vSphere can be done
   over an insecure connection. By default this is false.
+
+* `vm_folder` (string) - The folder within the datastore to store the VM.
+
+* `vm_network` (string) - The name of the VM network this VM will be
+  added to.
diff --git a/website/source/docs/provisioners/ansible-local.html.markdown b/website/source/docs/provisioners/ansible-local.html.markdown
index 40b883280..63b98ade4 100644
--- a/website/source/docs/provisioners/ansible-local.html.markdown
+++ b/website/source/docs/provisioners/ansible-local.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Ansible (Local) Provisioner"
+description: |-
+  The `ansible-local` Packer provisioner configures Ansible to run on the machine by Packer from local Playbook and Role files.  Playbooks and Roles can be uploaded from your local machine to the remote machine.  Ansible is run in local mode via the `ansible-playbook` command.
 ---
 
 # Ansible Local Provisioner
 
 Type: `ansible-local`
 
-The `ansible-local` provisioner configures Ansible to run on the machine by
+The `ansible-local` Packer provisioner configures Ansible to run on the machine by
 Packer from local Playbook and Role files.  Playbooks and Roles can be uploaded
 from your local machine to the remote machine.  Ansible is run in [local mode](http://docs.ansible.com/playbooks_delegation.html#local-playbooks) via the `ansible-playbook` command.
 
@@ -15,12 +17,12 @@ from your local machine to the remote machine.  Ansible is run in [local mode](h
 
 The example below is fully functional.
 
-<pre class="prettyprint">
+```javascript
 {
-    "type": "ansible-local",
-    "playbook_file": "local.yml"
+  "type": "ansible-local",
+  "playbook_file": "local.yml"
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -48,7 +50,8 @@ Optional:
   the `extra_arguments` option.
 
   An example inventory file may look like:
-  <pre class="prettyprint">
+
+  ```text
   [chi-dbservers]
   db-01 ansible_connection=local
   db-02 ansible_connection=local
@@ -66,12 +69,24 @@ Optional:
 
   [appservers:children]
   chi-appservers
-  </pre>
+  ```
+
+* `playbook_dir` (string) - a path to the complete ansible directory
+  structure on your local system to be copied to the remote machine
+  as the `staging_directory` before all other files and directories.
 
 * `playbook_paths` (array of strings) - An array of paths to playbook files on
   your local system. These will be uploaded to the remote machine under
   `staging_directory`/playbooks. By default, this is empty.
 
+* `group_vars` (string) - a path to the directory containing ansible
+  group variables on your local system to be copied to the
+  remote machine. By default, this is empty.
+
+* `host_vars` (string) - a path to the directory containing ansible
+  host variables on your local system to be copied to the
+  remote machine. By default, this is empty.
+
 * `role_paths` (array of strings) - An array of paths to role directories on
   your local system. These will be uploaded to the remote machine under
   `staging_directory`/roles. By default, this is empty.
diff --git a/website/source/docs/provisioners/chef-client.html.markdown b/website/source/docs/provisioners/chef-client.html.markdown
index 5c745a486..a3403e48e 100644
--- a/website/source/docs/provisioners/chef-client.html.markdown
+++ b/website/source/docs/provisioners/chef-client.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Chef-Client Provisioner"
+description: |-
+  The Chef Client Packer provisioner installs and configures software on machines built by Packer using chef-client. Packer configures a Chef client to talk to a remote Chef Server to provision the machine.
 ---
 
 # Chef Client Provisioner
 
 Type: `chef-client`
 
-The Chef Client provisioner installs and configures software on machines built
+The Chef Client Packer provisioner installs and configures software on machines built
 by Packer using [chef-client](http://docs.opscode.com/chef_client.html).
 Packer configures a Chef client to talk to a remote Chef Server to
 provision the machine.
@@ -20,12 +22,15 @@ installed, using the official Chef installers provided by Opscode.
 The example below is fully functional. It will install Chef onto the
 remote machine and run Chef client.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "chef-client",
-  "server_url": "http://mychefserver.com:4000/"
+  "server_url": "https://mychefserver.com/"
 }
-</pre>
+```
+
+Note: to properly clean up the Chef node and client, you must have
+`knife` on your path and properly configured.
 
 ## Configuration Reference
 
@@ -33,6 +38,9 @@ The reference of available configuration options is listed below. No
 configuration is actually required, but `node_name` is recommended
 since it will allow the provisioner to clean up the node/client.
 
+* `chef_environment` (string) - The name of the chef_environment sent to the
+  Chef server. By default this is empty and will not use an environment.
+
 * `config_template` (string) - Path to a template that will be used for
   the Chef configuration file. By default Packer only sets configuration
   it needs to match the settings set in the provisioner configuration. If
@@ -76,7 +84,7 @@ since it will allow the provisioner to clean up the node/client.
   on the machine using the Opscode omnibus installers.
 
 * `staging_directory` (string) - This is the directory where all the configuration
-  of Chef by Packer will be placed. By default this is "/tmp/packer-chef-solo".
+  of Chef by Packer will be placed. By default this is "/tmp/packer-chef-client".
   This directory doesn't need to exist but must have proper permissions so that
   the SSH user that Packer uses is able to create directories and write into
   this folder. If the permissions are not correct, use a shell provisioner
@@ -100,7 +108,7 @@ configuration template if you'd like to set custom configurations.
 
 The default value for the configuration template is:
 
-```
+```liquid
 log_level        :info
 log_location     STDOUT
 chef_server_url  "{{.ServerUrl}}"
@@ -125,7 +133,7 @@ and has a set of variables available to use:
 By default, Packer uses the following command (broken across multiple lines
 for readability) to execute Chef:
 
-```
+```liquid
 {{if .Sudo}}sudo {{end}}chef-client \
   --no-color \
   -c {{.ConfigPath}} \
@@ -148,7 +156,7 @@ By default, Packer uses the following command (broken across multiple lines
 for readability) to install Chef. This command can be customized if you want
 to install Chef in another way.
 
-```
+```text
 curl -L https://www.opscode.com/chef/install.sh | \
   {{if .Sudo}}sudo{{end}} bash
 ```
diff --git a/website/source/docs/provisioners/chef-solo.html.markdown b/website/source/docs/provisioners/chef-solo.html.markdown
index 5e68d933b..b60096307 100644
--- a/website/source/docs/provisioners/chef-solo.html.markdown
+++ b/website/source/docs/provisioners/chef-solo.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Chef-Solo Provisioner"
+description: |-
+  The Chef solo Packer provisioner installs and configures software on machines built by Packer using chef-solo. Cookbooks can be uploaded from your local machine to the remote machine or remote paths can be used.
 ---
 
 # Chef Solo Provisioner
 
 Type: `chef-solo`
 
-The Chef solo provisioner installs and configures software on machines built
+The Chef solo Packer provisioner installs and configures software on machines built
 by Packer using [chef-solo](http://docs.opscode.com/chef_solo.html). Cookbooks
 can be uploaded from your local machine to the remote machine or remote paths
 can be used.
@@ -20,12 +22,12 @@ installed, using the official Chef installers provided by Opscode.
 The example below is fully functional and expects cookbooks in the
 "cookbooks" directory relative to your working directory.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "chef-solo",
   "cookbook_paths": ["cookbooks"]
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -63,15 +65,15 @@ configuration is actually required, but at least `run_list` is recommended.
 * `json` (object) - An arbitrary mapping of JSON that will be available as
   node attributes while running Chef.
 
-* `remote_cookbook_paths` (array of string) - A list of paths on the remote
-  machine where cookbooks will already exist. These may exist from a previous
-  provisioner or step. If specified, Chef will be configured to look for
-  cookbooks here. By default, this is empty.
-
 * `prevent_sudo` (boolean) - By default, the configured commands that are
   executed to install and run Chef are executed with `sudo`. If this is true,
   then the sudo will be omitted.
 
+* `remote_cookbook_paths` (array of strings) - A list of paths on the remote
+  machine where cookbooks will already exist. These may exist from a previous
+  provisioner or step. If specified, Chef will be configured to look for
+  cookbooks here. By default, this is empty.
+
 * `roles_path` (string) - The path to the "roles" directory on your local filesystem.
   These will be uploaded to the remote machine in the directory specified by the
   `staging_directory`.  By default, this is empty.
@@ -98,7 +100,7 @@ configuration template if you'd like to set custom configurations.
 
 The default value for the configuration template is:
 
-```
+```liquid
 cookbook_path [{{.CookbookPaths}}]
 ```
 
@@ -112,14 +114,14 @@ and has a set of variables available to use:
 * `DataBagsPath` is the path to the data bags folder.
 * `EncryptedDataBagSecretPath` - The path to the encrypted data bag secret
 * `EnvironmentsPath` - The path to the environments folder.
-* `RolesPath` - The path the folders folder.
+* `RolesPath` - The path to the roles folder.
 
 ## Execute Command
 
 By default, Packer uses the following command (broken across multiple lines
 for readability) to execute Chef:
 
-```
+```liquid
 {{if .Sudo}}sudo {{end}}chef-solo \
   --no-color \
   -c {{.ConfigPath}} \
@@ -142,7 +144,7 @@ By default, Packer uses the following command (broken across multiple lines
 for readability) to install Chef. This command can be customized if you want
 to install Chef in another way.
 
-```
+```text
 curl -L https://www.opscode.com/chef/install.sh | \
   {{if .Sudo}}sudo{{end}} bash
 ```
diff --git a/website/source/docs/provisioners/custom.html.markdown b/website/source/docs/provisioners/custom.html.markdown
index c2dd3a527..08df184fd 100644
--- a/website/source/docs/provisioners/custom.html.markdown
+++ b/website/source/docs/provisioners/custom.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "Custom Provisioner"
+description: |-
+  Packer is extensible, allowing you to write new provisioners without having to modify the core source code of Packer itself. Documentation for creating new provisioners is covered in the custom provisioners page of the Packer plugin section.
 ---
 
 # Custom Provisioner
diff --git a/website/source/docs/provisioners/file.html.markdown b/website/source/docs/provisioners/file.html.markdown
index 4dea52ad8..a8d0daf56 100644
--- a/website/source/docs/provisioners/file.html.markdown
+++ b/website/source/docs/provisioners/file.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "File Provisioner"
+description: |-
+  The file Packer provisioner uploads files to machines built by Packer. The recommended usage of the file provisioner is to use it to upload files, and then use shell provisioner to move them to the proper place, set permissions, etc.
 ---
 
 # File Provisioner
 
 Type: `file`
 
-The file provisioner uploads files to machines built by Packer. The
+The file Packer provisioner uploads files to machines built by Packer. The
 recommended usage of the file provisioner is to use it to upload files,
 and then use [shell provisioner](/docs/provisioners/shell.html) to move
 them to the proper place, set permissions, etc.
@@ -16,13 +18,13 @@ The file provisioner can upload both single files and complete directories.
 
 ## Basic Example
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "file",
   "source": "app.tar.gz",
   "destination": "/tmp/app.tar.gz"
 }
-</pre>
+```
 
 ## Configuration Reference
 
diff --git a/website/source/docs/provisioners/puppet-masterless.html.markdown b/website/source/docs/provisioners/puppet-masterless.html.markdown
index 23c07f433..b3574cac6 100644
--- a/website/source/docs/provisioners/puppet-masterless.html.markdown
+++ b/website/source/docs/provisioners/puppet-masterless.html.markdown
@@ -1,38 +1,38 @@
 ---
 layout: "docs"
 page_title: "Puppet (Masterless) Provisioner"
+description: |-
+  The masterless Puppet Packer provisioner configures Puppet to run on the machines by Packer from local modules and manifest files. Modules and manifests can be uploaded from your local machine to the remote machine or can simply use remote paths (perhaps obtained using something like the shell provisioner). Puppet is run in masterless mode, meaning it never communicates to a Puppet master.
 ---
 
 # Puppet (Masterless) Provisioner
 
 Type: `puppet-masterless`
 
-The masterless Puppet provisioner configures Puppet to run on the machines
+The masterless Puppet Packer provisioner configures Puppet to run on the machines
 by Packer from local modules and manifest files. Modules and manifests
 can be uploaded from your local machine to the remote machine or can simply
 use remote paths (perhaps obtained using something like the shell provisioner).
 Puppet is run in masterless mode, meaning it never communicates to a Puppet
 master.
 
-<div class="alert alert-info alert-block">
-<strong>Note that Puppet will <em>not</em> be installed automatically
-by this provisioner.</strong> This provisioner expects that Puppet is already
+-> **Note:** Puppet will _not_ be installed automatically
+by this provisioner. This provisioner expects that Puppet is already
 installed on the machine. It is common practice to use the
-<a href="/docs/provisioners/shell.html">shell provisioner</a> before the
+[shell provisioner[(/docs/provisioners/shell.html) before the
 Puppet provisioner to do this.
-</div>
 
 ## Basic Example
 
 The example below is fully functional and expects the configured manifest
 file to exist relative to your working directory:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "puppet-masterless",
   "manifest_file": "site.pp"
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -60,7 +60,9 @@ Optional parameters:
 
 * `manifest_dir` (string) - The path to a local directory with manifests
   to be uploaded to the remote machine. This is useful if your main
-  manifest file uses imports.
+  manifest file uses imports. This directory doesn't necessarily contain
+  the `manifest_file`. It is a separate directory that will be set as
+  the "manifestdir" setting on Puppet.
 
 * `module_paths` (array of strings) - This is an array of paths to module
   directories on your local filesystem. These will be uploaded to the remote
@@ -82,7 +84,7 @@ Optional parameters:
 By default, Packer uses the following command (broken across multiple lines
 for readability) to execute Puppet:
 
-```
+```liquid
 {{.FacterVars}}{{if .Sudo}} sudo -E {{end}}puppet apply \
   --verbose \
   --modulepath='{{.ModulePath}}' \
@@ -104,4 +106,3 @@ can contain various template variables, defined below:
 * `ModulePath` - The paths to the module directories.
 * `Sudo` - A boolean of whether to `sudo` the command or not, depending on
   the value of the `prevent_sudo` configuration.
-
diff --git a/website/source/docs/provisioners/puppet-server.html.markdown b/website/source/docs/provisioners/puppet-server.html.markdown
index 413e1831e..f60e88f50 100644
--- a/website/source/docs/provisioners/puppet-server.html.markdown
+++ b/website/source/docs/provisioners/puppet-server.html.markdown
@@ -1,29 +1,29 @@
 ---
 layout: "docs"
 page_title: "Puppet Server Provisioner"
+description: |-
+  The `puppet-server` Packer provisioner provisions Packer machines with Puppet by connecting to a Puppet master.
 ---
 
 # Puppet Server Provisioner
 
 Type: `puppet-server`
 
-The `puppet-server` provisioner provisions Packer machines with Puppet
+The `puppet-server` Packer provisioner provisions Packer machines with Puppet
 by connecting to a Puppet master.
 
-<div class="alert alert-info alert-block">
-<strong>Note that Puppet will <em>not</em> be installed automatically
-by this provisioner.</strong> This provisioner expects that Puppet is already
+-> **Note:** Puppet will _not_ be installed automatically
+by this provisioner. This provisioner expects that Puppet is already
 installed on the machine. It is common practice to use the
-<a href="/docs/provisioners/shell.html">shell provisioner</a> before the
+[shell provisioner](/docs/provisioners/shell.html) before the
 Puppet provisioner to do this.
-</div>
 
 ## Basic Example
 
 The example below is fully functional and expects a Puppet server to be accessible
 from your network.:
 
-<pre class="prettyprint">
+```javascript
 {
    "type": "puppet-server",
    "options": "--test --pluginsync",
@@ -31,7 +31,7 @@ from your network.:
      "server_role": "webserver"
    }
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -54,16 +54,16 @@ required. They are listed below:
 * `options` (string) - Additional command line options to pass
   to `puppet agent` when Puppet is ran.
 
+* `prevent_sudo` (boolean) - By default, the configured commands that are
+  executed to run Puppet are executed with `sudo`. If this is true,
+  then the sudo will be omitted.
+
 * `puppet_node` (string) - The name of the node. If this isn't set,
    the fully qualified domain name will be used.
 
 * `puppet_server` (string) - Hostname of the Puppet server. By default
   "puppet" will be used.
 
-* `prevent_sudo` (boolean) - By default, the configured commands that are
-  executed to run Puppet are executed with `sudo`. If this is true,
-  then the sudo will be omitted.
-
 * `staging_directory` (string) - This is the directory where all the configuration
   of Puppet by Packer will be placed. By default this is "/tmp/packer-puppet-server".
   This directory doesn't need to exist but must have proper permissions so that
diff --git a/website/source/docs/provisioners/salt-masterless.html.markdown b/website/source/docs/provisioners/salt-masterless.html.markdown
index c0dbead7c..a298bb28d 100644
--- a/website/source/docs/provisioners/salt-masterless.html.markdown
+++ b/website/source/docs/provisioners/salt-masterless.html.markdown
@@ -1,25 +1,27 @@
 ---
 layout: "docs"
 page_title: "Salt (Masterless) Provisioner"
+description: |-
+  The `salt-masterless` Packer provisioner provisions machines built by Packer using Salt states, without connecting to a Salt master.
 ---
 
 # Salt Masterless Provisioner
 
 Type: `salt-masterless`
 
-The `salt-masterless` provisioner provisions machines built by Packer using
+The `salt-masterless` Packer provisioner provisions machines built by Packer using
 [Salt](http://saltstack.com/) states, without connecting to a Salt master.
 
 ## Basic Example
 
 The example below is fully functional.
 
-<pre class="prettyprint">
+```javascript
 {
-    "type": "salt-masterless",
-    "local_state_tree": "/Users/me/salt"
+  "type": "salt-masterless",
+  "local_state_tree": "/Users/me/salt"
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -27,27 +29,27 @@ The reference of available configuration options is listed below. The only requi
 
 Optional:
 
-* `local_state_tree` (string) - The path to your local
-  [state tree](http://docs.saltstack.com/ref/states/highstate.html#the-salt-state-tree).
-  This will be uploaded to the `/srv/salt` on the remote.
-
-* `local_pillar_roots` (string) - The path to your local
-  [pillar roots](http://docs.saltstack.com/ref/configuration/master.html#pillar-configuration).
-  This will be uploaded to the `/srv/pillar` on the remote.
-
-* `skip_bootstrap` (boolean) - By default the salt provisioner runs
-  [salt bootstrap](https://github.com/saltstack/salt-bootstrap) to install
-  salt. Set this to true to skip this step.
-
 * `bootstrap_args` (string) - Arguments to send to the bootstrap script. Usage
   is somewhat documented on [github](https://github.com/saltstack/salt-bootstrap),
   but the [script itself](https://github.com/saltstack/salt-bootstrap/blob/develop/bootstrap-salt.sh)
   has more detailed usage instructions. By default, no arguments are sent to
   the script.
 
+* `local_pillar_roots` (string) - The path to your local
+  [pillar roots](http://docs.saltstack.com/ref/configuration/master.html#pillar-configuration).
+  This will be uploaded to the `/srv/pillar` on the remote.
+
+* `local_state_tree` (string) - The path to your local
+  [state tree](http://docs.saltstack.com/ref/states/highstate.html#the-salt-state-tree).
+  This will be uploaded to the `/srv/salt` on the remote.
+
 * `minion_config` (string) - The path to your local
   [minion config](http://docs.saltstack.com/topics/configuration.html).
   This will be uploaded to the `/etc/salt` on the remote.
 
+* `skip_bootstrap` (boolean) - By default the salt provisioner runs
+  [salt bootstrap](https://github.com/saltstack/salt-bootstrap) to install
+  salt. Set this to true to skip this step.
+
 * `temp_config_dir` (string) - Where your local state tree will be copied
   before moving to the `/srv/salt` directory. Default is `/tmp/salt`.
diff --git a/website/source/docs/provisioners/shell.html.markdown b/website/source/docs/provisioners/shell.html.markdown
index d47b59733..ffed1e442 100644
--- a/website/source/docs/provisioners/shell.html.markdown
+++ b/website/source/docs/provisioners/shell.html.markdown
@@ -1,13 +1,15 @@
 ---
 layout: "docs"
 page_title: "Shell Provisioner"
+description: |-
+  The shell Packer provisioner provisions machines built by Packer using shell scripts. Shell provisioning is the easiest way to get software installed and configured on a machine.
 ---
 
 # Shell Provisioner
 
 Type: `shell`
 
-The shell provisioner provisions machines built by Packer using shell scripts.
+The shell Packer provisioner provisions machines built by Packer using shell scripts.
 Shell provisioning is the easiest way to get software installed and configured
 on a machine.
 
@@ -15,12 +17,12 @@ on a machine.
 
 The example below is fully functional.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "shell",
   "inline": ["echo foo"]
 }
-</pre>
+```
 
 ## Configuration Reference
 
@@ -33,7 +35,7 @@ Exactly _one_ of the following is required:
   The commands are concatenated by newlines and turned into a single file,
   so they are all executed within the same context. This allows you to
   change directories in one command and use something in the directory in
-  the next and so on. Inline scripts are the easiest way to pull of simple
+  the next and so on. Inline scripts are the easiest way to pull off simple
   tasks within the machine.
 
 * `script` (string) - The path to a script to upload and execute in the machine.
@@ -87,7 +89,7 @@ For example, if the default user of an installed operating system is "packer"
 and has the password "packer" for sudo usage, then you'll likely want to
 change `execute_command` to be:
 
-```
+```text
 "echo 'packer' | {{ .Vars }} sudo -E -S sh '{{ .Path }}'"
 ```
 
@@ -128,7 +130,7 @@ return and Packer will start executing the next one before SSH actually
 quits and the machine restarts. For this, put a long `sleep` after the
 reboot so that SSH will eventually be killed automatically:
 
-```
+```text
 reboot
 sleep 60
 ```
@@ -138,7 +140,7 @@ reboot, causing the provisioner to hang despite a reboot occuring.
 In this case, make sure you shut down the network interfaces
 on reboot or in your shell script. For example, on Gentoo:
 
-```
+```text
 /etc/init.d/net.eth0 stop
 ```
 
@@ -173,9 +175,9 @@ will echo the script statements as it is executing.
 can create race conditions. Your first provisoner can tell the machine to
 wait until it completely boots.
 
-<pre class="prettyprint">
-    {
-       "type": "shell",
-       "inline": [ "sleep 10" ]
-    }
-</pre>
+```javascript
+{
+  "type": "shell",
+  "inline": [ "sleep 10" ]
+}
+```
diff --git a/website/source/docs/templates/builders.html.markdown b/website/source/docs/templates/builders.html.markdown
index d82e20b49..0226d30d5 100644
--- a/website/source/docs/templates/builders.html.markdown
+++ b/website/source/docs/templates/builders.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Templates: Builders"
+description: |-
+  Within the template, the builders section contains an array of all the builders that Packer should use to generate a machine images for the template.
 ---
 
 # Templates: Builders
@@ -18,13 +21,13 @@ must be referenced from the documentation for that specific builder.
 
 Within a template, a section of builder definitions looks like this:
 
-<pre class="prettyprint">
+```javascript
 {
   "builders": [
-    ... one or more builder definitions here ...
+    // ... one or more builder definitions here
   ]
 }
-</pre>
+```
 
 ## Builder Definition
 
@@ -40,13 +43,13 @@ some other settings. These are placed directly within the builder definition.
 An example builder definition is shown below, in this case configuring
 the AWS builder:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "amazon-ebs",
   "access_key": "...",
   "secret_key": "..."
 }
-</pre>
+```
 
 ## Named Builds
 
diff --git a/website/source/docs/templates/configuration-templates.html.markdown b/website/source/docs/templates/configuration-templates.html.markdown
index f2c42c2fb..bf6b31e36 100644
--- a/website/source/docs/templates/configuration-templates.html.markdown
+++ b/website/source/docs/templates/configuration-templates.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "Configuration Templates"
+description: |-
+  All strings within templates are processed by a common Packer templating engine, where variables and functions can be used to modify the value of a configuration parameter at runtime.
 ---
 
 # Configuration Templates
@@ -32,20 +34,20 @@ within the braces, such as `{{timestamp}}`.
 Here is an example from the VMware VMX template that shows configuration
 templates in action:
 
-<pre>
+```liquid
 .encoding = "UTF-8"
 displayName = "{{ .Name }}"
 guestOS = "{{ .GuestOS }}"
-</pre>
+```
 
 In this case, the "Name" and "GuestOS" variables will be replaced, potentially
 resulting in a VMX that looks like this:
 
-<pre>
+```liquid
 .encoding = "UTF-8"
 displayName = "packer"
 guestOS = "otherlinux"
-</pre>
+```
 
 ## Global Functions
 
@@ -53,10 +55,71 @@ While some configuration settings have local variables specific to only that
 configuration, a set of functions are available globally for use in _any string_
 in Packer templates. These are listed below for reference.
 
+* `lower` - Lowercases the string.
 * `pwd` - The working directory while executing Packer.
-* `isotime` - UTC time in RFC-3339 format.
+* `isotime [FORMAT]` - UTC time, which can be [formatted](http://golang.org/pkg/time/#example_Time_Format).
+   See more examples below.
 * `timestamp` - The current Unix timestamp in UTC.
 * `uuid` - Returns a random UUID.
+* `upper` - Uppercases the string.
+
+### isotime Format
+
+Formatting for the function `isotime` uses the magic reference date
+**Mon Jan 2 15:04:05 -0700 MST 2006**, which breaks down to the following:
+
+<div class="table-responsive">
+<table class="table table-bordered table-condensed">
+<thead>
+<tr>
+<th></th>
+<th align="center">Day of Week</th>
+<th align="center">Month</th>
+<th align="center">Date</th>
+<th align="center">Hour</th>
+<th align="center">Minute</th>
+<th align="center">Second</th>
+<th align="center">Year</th>
+<th align="center">Timezone</th>
+</tr>
+</thead>
+<tr>
+<th>Numeric</th>
+<td align="center">-</td>
+<td align="center">01</td>
+<td align="center">02</td>
+<td align="center">03 (15)</td>
+<td align="center">04</td>
+<td align="center">05</td>
+<td align="center">06</td>
+<td align="center">-0700</td>
+</tr>
+<tr>
+<th>Textual</th>
+<td align="center">Monday (Mon)</td>
+<td align="center">January (Jan)</td>
+<td align="center">-</td>
+<td align="center">-</td>
+<td align="center">-</td>
+<td align="center">-</td>
+<td align="center">-</td>
+<td align="center">MST</td>
+</tr>
+</table>
+</div>
+
+ _The values in parentheses are the abbreviated, or 24-hour clock values_
+
+ Here are some example formated time, using the above format options:
+
+```liquid
+isotime = June 7, 7:22:43pm 2014
+
+{{isotime "2006-01-02"}} = 2014-06-07
+{{isotime "Mon 1506"}} = Sat 1914
+{{isotime "01-Jan-06 03\_04\_05"}} = 07-Jun-2014 07\_22\_43
+{{isotime "Hour15Year200603"}} = Hour19Year201407
+```
 
 ## Amazon Specific Functions
 
diff --git a/website/source/docs/templates/introduction.html.markdown b/website/source/docs/templates/introduction.html.markdown
index 6b11cc851..a8be4f592 100644
--- a/website/source/docs/templates/introduction.html.markdown
+++ b/website/source/docs/templates/introduction.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Templates"
+description: |-
+  Templates are JSON files that configure the various components of Packer in order to create one or more machine images. Templates are portable, static, and readable and writable by both humans and computers. This has the added benefit of being able to not only create and modify templates by hand, but also write scripts to dynamically create or modify templates.
 ---
 
 # Templates
@@ -20,28 +23,15 @@ A template is a JSON object that has a set of keys configuring various
 components of Packer. The available keys within a template are listed below.
 Along with each key, it is noted whether it is required or not.
 
-* `description` (optional) is a string providing a description of what
-  the template does. This output is used only in the
-  [inspect command](/docs/command-line/inspect.html).
-
 * `builders` (_required_) is an array of one or more objects that defines
   the builders that will be used to create machine images for this template,
   and configures each of those builders. For more information on how to define
   and configure a builder, read the sub-section on
   [configuring builders in templates](/docs/templates/builders.html).
 
-* `provisioners` (optional) is an array of one or more objects that defines
-  the provisioners that will be used to install and configure software for
-  the machines created by each of the builders. This is an optional field.
-  If it is not specified, then no provisioners will be run. For more
-  information on how to define and configure a provisioner, read the
-  sub-section on [configuring provisioners in templates](/docs/templates/provisioners.html).
-
-* `post-processors` (optional) is an array of one or more objects that defines the
-  various post-processing steps to take with the built images. This is an optional
-  field. If not specified, then no post-processing will be done. For more
-  information on what post-processors do and how they're defined, read the
-  sub-section on [configuring post-processors in templates](/docs/templates/post-processors.html).
+* `description` (optional) is a string providing a description of what
+  the template does. This output is used only in the
+  [inspect command](/docs/command-line/inspect.html).
 
 * `min_packer_version` (optional) is a string that has a minimum Packer
   version that is required to parse the template. This can be used to
@@ -49,13 +39,32 @@ Along with each key, it is noted whether it is required or not.
   max version can't be specified because Packer retains backwards
   compatibility with `packer fix`.
 
+* `post-processors` (optional) is an array of one or more objects that defines the
+  various post-processing steps to take with the built images. If not specified,
+  then no post-processing will be done. For more
+  information on what post-processors do and how they're defined, read the
+  sub-section on [configuring post-processors in templates](/docs/templates/post-processors.html).
+
+* `provisioners` (optional) is an array of one or more objects that defines
+  the provisioners that will be used to install and configure software for
+  the machines created by each of the builders. If it is not specified,
+  then no provisioners will be run. For more
+  information on how to define and configure a provisioner, read the
+  sub-section on [configuring provisioners in templates](/docs/templates/provisioners.html).
+
+* `variables` (optional) is an array of one or more key/value strings that defines
+  user variables contained in the template.
+  If it is not specified, then no variables are defined.
+  For more information on how to define and use user variables, read the
+  sub-section on [user variables in templates](/docs/templates/user-variables.html).
+
 ## Example Template
 
 Below is an example of a basic template that is nearly fully functional. It is just
 missing valid AWS access keys. Otherwise, it would work properly with
 `packer build`.
 
-<pre class="prettyprint">
+```javascript
 {
   "builders": [
     {
@@ -77,4 +86,4 @@ missing valid AWS access keys. Otherwise, it would work properly with
     }
   ]
 }
-</pre>
+```
diff --git a/website/source/docs/templates/post-processors.html.markdown b/website/source/docs/templates/post-processors.html.markdown
index cda12e2a2..7a7ba4664 100644
--- a/website/source/docs/templates/post-processors.html.markdown
+++ b/website/source/docs/templates/post-processors.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Templates: Post-Processors"
+description: |-
+  The post-processor section within a template configures any post-processing that will be done to images built by the builders. Examples of post-processing would be compressing files, uploading artifacts, etc.
 ---
 
 # Templates: Post-Processors
@@ -18,13 +21,13 @@ however, must be referenced from the documentation for that specific post-proces
 
 Within a template, a section of post-processor definitions looks like this:
 
-<pre class="prettyprint">
+```javascript
 {
   "post-processors": [
-    ... one or more post-processor definitions here ...
+    // ... one or more post-processor definitions here
   ]
 }
-</pre>
+```
 
 For each post-processor definition, Packer will take the result of each of the
 defined builders and send it through the post-processors. This means that if you
@@ -45,11 +48,11 @@ A **simple definition** is just a string; the name of the post-processor. An
 example is shown below. Simple definitions are used when no additional configuration
 is needed for the post-processor.
 
-<pre class="prettyprint">
+```javascript
 {
   "post-processors": ["compress"]
 }
-</pre>
+```
 
 A **detailed definition** is a JSON object. It is very similar to a builder
 or provisioner definition. It contains a `type` field to denote the type of
@@ -57,7 +60,7 @@ the post-processor, but may also contain additional configuration for the
 post-processor. A detailed definition is used when additional configuration
 is needed beyond simply the type for the post-processor. An example is shown below.
 
-<pre class="prettyprint">
+```javascript
 {
   "post-processors": [
     {
@@ -66,7 +69,7 @@ is needed beyond simply the type for the post-processor. An example is shown bel
     }
   ]
 }
-</pre>
+```
 
 A **sequence definition** is a JSON array comprised of other **simple** or
 **detailed** definitions. The post-processors defined in the array are run
@@ -76,16 +79,16 @@ sequence definition. Sequence definitions are used to chain together multiple
 post-processors. An example is shown below, where the artifact of a build is
 compressed then uploaded, but the compressed result is not kept.
 
-<pre class="prettyprint">
+```javascript
 {
   "post-processors": [
     [
       "compress",
-      { "type": "upload", "endpoint": "http://fake.com" }
+      { "type": "upload", "endpoint": "http://example.com" }
     ]
   ]
 }
-</pre>
+```
 
 As you may be able to imagine, the **simple** and **detailed** definitions
 are simply shortcuts for a **sequence** definition of only one element.
@@ -101,7 +104,7 @@ In some cases, however, you may want to keep the intermediary artifacts.
 You can tell Packer to keep these artifacts by setting the
 `keep_input_artifact` configuration to `true`. An example is shown below:
 
-<pre class="prettyprint">
+```javascript
 {
   "post-processors": [
     {
@@ -110,21 +113,19 @@ You can tell Packer to keep these artifacts by setting the
     }
   ]
 }
-</pre>
+```
 
 This setting will only keep the input artifact to _that specific_
 post-processor. If you're specifying a sequence of post-processors, then
 all intermediaries are discarded by default except for the input artifacts
 to post-processors that explicitly state to keep the input artifact.
 
-<div class="alert alert-info alert-block">
-<strong>Note:</strong> The intuitive reader may be wondering what happens
+-> **Note:** The intuitive reader may be wondering what happens
 if multiple post-processors are specified (not in a sequence). Does Packer require the
 configuration to keep the input artifact on all the post-processors?
 The answer is no, of course not. Packer is smart enough to figure out
 that at least one post-processor requested that the input be kept, so it will keep
 it around.
-</div>
 
 ## Run on Specific Builds
 
@@ -139,12 +140,12 @@ is effectively the same. `only` and `except` can only be specified on "detailed"
 configurations. If you have a sequence of post-processors to run, `only`
 and `except` will only affect that single post-processor in the sequence.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "vagrant",
-  "only": ["virtualbox"]
+  "only": ["virtualbox-iso"]
 }
-</pre>
+```
 
 The values within `only` or `except` are _build names_, not builder
 types. If you recall, build names by default are just their builder type,
diff --git a/website/source/docs/templates/provisioners.html.markdown b/website/source/docs/templates/provisioners.html.markdown
index 327ae46e7..00578bb86 100644
--- a/website/source/docs/templates/provisioners.html.markdown
+++ b/website/source/docs/templates/provisioners.html.markdown
@@ -1,5 +1,8 @@
 ---
 layout: "docs"
+page_title: "Templates: Provisioners"
+description: |-
+  Within the template, the provisioners section contains an array of all the provisioners that Packer should use to install and configure software within running machines prior to turning them into machine images.
 ---
 
 # Templates: Provisioners
@@ -20,13 +23,13 @@ must be referenced from the documentation for that specific provisioner.
 
 Within a template, a section of provisioner definitions looks like this:
 
-<pre class="prettyprint">
+```javascript
 {
   "provisioners": [
-    ... one or more provisioner definitions here ...
+    // ... one or more provisioner definitions here
   ]
 }
-</pre>
+```
 
 For each of the definitions, Packer will run the provisioner for each
 of the configured builds. The provisioners will be run in the order
@@ -46,12 +49,12 @@ being created.
 An example provisioner definition is shown below, configuring the shell
 provisioner to run a local script within the machines:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "shell",
   "script": "script.sh"
 }
-</pre>
+```
 
 ## Run on Specific Builds
 
@@ -64,13 +67,13 @@ builds.
 An example of `only` being used is shown below, but the usage of `except`
 is effectively the same:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "shell",
   "script": "script.sh",
-  "only": ["virtualbox"]
+  "only": ["virtualbox-iso"]
 }
-</pre>
+```
 
 The values within `only` or `except` are _build names_, not builder
 types. If you recall, build names by default are just their builder type,
@@ -94,18 +97,18 @@ identical. However, they may initially need to be run differently.
 
 This example is shown below:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "shell",
   "script": "script.sh",
 
   "override": {
-    "vmware": {
+    "vmware-iso": {
       "execute_command": "echo 'password' | sudo -S bash {{.Path}}"
     }
   }
 }
-</pre>
+```
 
 As you can see, the `override` key is used. The value of this key is another
 JSON object where the key is the name of a [builder definition](/docs/templates/builders.html).
@@ -125,13 +128,13 @@ configuration `pause_before` that is the amount of time to pause before
 running that provisioner. By default, there is no pause. An example
 is shown below:
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "shell",
   "script": "script.sh",
   "pause_before": "10s"
 }
-</pre>
+```
 
 For the above provisioner, Packer will wait 10 seconds before uploading
 and executing the shell script.
diff --git a/website/source/docs/templates/user-variables.html.markdown b/website/source/docs/templates/user-variables.html.markdown
index f1ab19c5c..ae6ef3cd3 100644
--- a/website/source/docs/templates/user-variables.html.markdown
+++ b/website/source/docs/templates/user-variables.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "User Variables in Templates"
+description: |-
+  User variables allow your templates to be further configured with variables from the command-line, environmental variables, or files. This lets you parameterize your templates so that you can keep secret tokens, environment-specific data, and other types of information out of your templates. This maximizes the portablility and shareability of the template.
 ---
 
 # User Variables
@@ -9,7 +11,7 @@ User variables allow your templates to be further configured with variables
 from the command-line, environmental variables, or files. This lets you
 parameterize your templates so that you can keep secret tokens,
 environment-specific data, and other types of information out of your
-templates. This maximizes the portablility and shareability of the template.
+templates. This maximizes the portability and shareability of the template.
 
 Using user variables expects you know how
 [configuration templates](/docs/templates/configuration-templates.html) work.
@@ -20,14 +22,14 @@ page first.
 
 User variables must first be defined in a `variables` section within your
 template. Even if you want a variable to default to an empty string, it
-must be defined. This explicivity makes it easy for newcomers to your
+must be defined. This explicitness makes it easy for newcomers to your
 template to understand what can be modified using variables in your template.
 
 The `variables` section is a simple key/value mapping of the variable
 name to a default value. A default value can be the empty string. An
 example is shown below:
 
-<pre class="prettyprint">
+```javascript
 {
   "variables": {
     "aws_access_key": "",
@@ -38,10 +40,10 @@ example is shown below:
     "type": "amazon-ebs",
     "access_key": "{{user `aws_access_key`}}",
     "secret_key": "{{user `aws_secret_key`}}",
-    ...
+    // ...
   }]
 }
-</pre>
+```
 
 In the above example, the template defines two variables: `aws_access_key` and
 `aws_secret_key`. They default to empty values.
@@ -65,28 +67,26 @@ variables. The `env` function is available _only_ within the default value
 of a user variable, allowing you to default a user variable to an
 environmental variable. An example is shown below:
 
-<pre class="prettyprint">
+```javascript
 {
   "variables": {
     "my_secret": "{{env `MY_SECRET`}}",
   },
 
-  ...
+  // ...
 }
-</pre>
+```
 
 This will default "my\_secret" to be the value of the "MY\_SECRET"
 environmental variable (or the empty string if it does not exist).
 
-<div class="alert alert-info">
-<strong>Why can't I use environmental variables elsewhere?</strong>
+-> **Why can't I use environmental variables elsewhere?**
 User variables are the single source of configurable input to a template.
-We felt that having environmental variables used <em>anywhere</em> in a
+We felt that having environmental variables used _anywhere_ in a
 template would confuse the user about the possible inputs to a template.
 By allowing environmental variables only within default values for user
 variables, user variables remain as the single source of input to a template
-that a user can easily discover using <code>packer inspect</code>.
-</div>
+that a user can easily discover using `packer inspect`.
 
 ## Setting Variables
 
@@ -103,7 +103,7 @@ above, we could build our template using the command below. The command
 is split across multiple lines for readability, but can of course be a single
 line.
 
-```
+```text
 $ packer build \
     -var 'aws_access_key=foo' \
     -var 'aws_secret_key=bar' \
@@ -124,18 +124,18 @@ Variables can also be set from an external JSON file. The `-var-file`
 flag reads a file containing a basic key/value mapping of variables to
 values and sets those variables. The JSON file is simple:
 
-<pre class="prettyprint">
+```javascript
 {
   "aws_access_key": "foo",
   "aws_secret_key": "bar"
 }
-</pre>
+```
 
 It is a single JSON object where the keys are variables and the values are
 the variable values. Assuming this file is in `variables.json`, we can
 build our template using the following command:
 
-```
+```text
 $ packer build -var-file=variables.json template.json
 ```
 
diff --git a/website/source/docs/templates/veewee-to-packer.html.markdown b/website/source/docs/templates/veewee-to-packer.html.markdown
index 1fbb43edf..81a06de71 100644
--- a/website/source/docs/templates/veewee-to-packer.html.markdown
+++ b/website/source/docs/templates/veewee-to-packer.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "docs"
 page_title: "Convert Veewee Definitions to Packer Templates"
+description: |-
+  If you are or were a user of Veewee, then there is an official tool called veewee-to-packer that will convert your Veewee definition into an equivalent Packer template. Even if you're not a Veewee user, Veewee has a large library of templates that can be readily used with Packer by simply converting them.
 ---
 
 # Veewee-to-Packer
@@ -17,7 +19,7 @@ of templates that can be readily used with Packer by simply converting them.
 Since Veewee itself is a Ruby project, so too is the veewee-to-packer
 application so that it can read the Veewee configurations. Install it using RubyGems:
 
-```
+```text
 $ gem install veewee-to-packer
 ...
 ```
@@ -27,7 +29,7 @@ at the `definition.rb` file of any template. The converter will output
 any warnings or messages about the conversion. The example below converts
 a CentOS template:
 
-```
+```text
 $ veewee-to-packer templates/CentOS-6.4/definition.rb
 Success! Your Veewee definition was converted to a Packer
 template! The template can be found in the `template.json` file
diff --git a/website/source/downloads.html.erb b/website/source/downloads.html.erb
index 38465d300..d10dfb5c6 100644
--- a/website/source/downloads.html.erb
+++ b/website/source/downloads.html.erb
@@ -12,24 +12,24 @@ page_title: "Downloads"
 <section class="downloads">
 <div class="container">
 	<div class="description row">
-		<div class="span8 offset2">
+		<div class="col-md-8 col-md-offset-2">
 			<p>
 			Below are all available downloads for the latest version of Packer
 			(<%= latest_version %>). Please download the proper package for your
 			operating system and architecture. You can find SHA256 checksums
-			for packages <a href="https://dl.bintray.com/mitchellh/packer/<%= latest_version %>_SHA256SUMS?direct">here</a>.
+			for packages <a href="https://dl.bintray.com/mitchellh/packer/packer_<%= latest_version %>_SHA256SUMS?direct">here</a>.
 			</p>
 		</div>
 	</div>
-	<% $packer_os.each do |os| %>
+	<% product_versions.each do |os, versions| %>
 		<div class="row">
-			<div class="span8 offset2 download">
-				<div class="icon pull-left"><%= image_tag "/images/icons/icon_#{os}.png" %></div>
+			<div class="col-md-8 col-md-offset-2 download">
+				<div class="icon pull-left"><%= system_icon(os) %></div>
 				<div class="details">
-					<h2 class="os-name"><%= download_os_human(os) %></h2>
+					<h2 class="os-name"><%= os %></h2>
 					<ul>
-						<% $packer_files[os].each do |file| %>
-						<li><a href="<%= download_url(file) %>"><%= download_arch(file) %></a></li>
+						<% versions.each do |url| %>
+						<li><a href="<%= url %>"><%= arch_for_filename(url) %></a></li>
 						<% end %>
 					</ul>
 					<div class="clearfix"></div>
@@ -39,9 +39,9 @@ page_title: "Downloads"
 	<% end %>
 
 	<div class="row">
-		<div class="span8 offset2 poweredby">
+		<div class="col-md-8 col-md-offset-2 poweredby">
 			<a href='http://www.bintray.com'>
-				<img src='http://www.bintray.com/docs/images/poweredByBintray_ColorTransparent.png'>
+				<img src='https://www.bintray.com/docs/images/poweredByBintray_ColorTransparent.png'>
 			</a>
 		</div>
 	</div>
diff --git a/website/source/images/icons/icon_darwin.png b/website/source/images/icons/icon_darwin.png
deleted file mode 100644
index c9ad9fe04..000000000
Binary files a/website/source/images/icons/icon_darwin.png and /dev/null differ
diff --git a/website/source/images/icons/icon_freebsd.png b/website/source/images/icons/icon_freebsd.png
deleted file mode 100644
index b5aad9299..000000000
Binary files a/website/source/images/icons/icon_freebsd.png and /dev/null differ
diff --git a/website/source/images/icons/icon_linux.png b/website/source/images/icons/icon_linux.png
deleted file mode 100644
index 7753dfb9e..000000000
Binary files a/website/source/images/icons/icon_linux.png and /dev/null differ
diff --git a/website/source/images/icons/icon_openbsd.png b/website/source/images/icons/icon_openbsd.png
deleted file mode 100644
index a9ee0423e..000000000
Binary files a/website/source/images/icons/icon_openbsd.png and /dev/null differ
diff --git a/website/source/images/icons/icon_windows.png b/website/source/images/icons/icon_windows.png
deleted file mode 100644
index d7748c009..000000000
Binary files a/website/source/images/icons/icon_windows.png and /dev/null differ
diff --git a/website/source/index.html.erb b/website/source/index.html.erb
index 655b48737..6c6ddc5dd 100644
--- a/website/source/index.html.erb
+++ b/website/source/index.html.erb
@@ -1,9 +1,14 @@
+---
+description: |-
+  Packer is a free and open source tool for creating golden images for multiple platforms from a single source configuration.
+---
+
 <div class="home">
 
 	<header class="dark-background">
 	<div class="container hero">
 		<div class="row">
-			<div class="span6 offset1">
+			<div class="col-md-4 col-md-offset-1">
 				<h2>
 					<span class="text-green">Packer</span> is a tool for creating identical machine images for multiple platforms from a single source configuration.
 				</h2>
@@ -26,11 +31,11 @@
 	<section class="marketting padded-lg">
 	<div class="container">
 		<div class="row">
-			<div class="span6">
-				<img src="/images/screenshots/vmware_and_virtualbox.png">
+			<div class="col-md-6">
+        <%= image_tag 'screenshots/vmware_and_virtualbox.png', class: 'img-responsive' %>
 			</div>
 
-			<div class="span6">
+			<div class="col-md-6">
 				<h2 class="text-green text-center">Modern, Automated</h2>
 				<p>
 				Packer is easy to use and automates the creation of any type
@@ -49,18 +54,19 @@
 	<section class="marketting padded-lg">
 	<div class="container">
 		<div class="row">
-			<div class="span6">
+			<div class="col-md-6">
 				<h2 class="text-green text-center">Works Great With</h2>
 				<p>
 					Out of the box Packer comes with support to build images for
-					Amazon EC2, DigitalOcean, VirtualBox, and VMware. Support for
+					Amazon EC2, DigitalOcean, Google Compute Engine, QEMU,
+					VirtualBox, VMware, and more. Support for
 					more platforms is on the way, and anyone can add new platforms
 					via plugins.
 				</p>
 			</div>
 
-			<div class="span6">
-				<img src="/images/screenshots/works_with.png">
+			<div class="col-md-6">
+        <%= image_tag 'screenshots/works_with.png', class: 'img-responsive' %>
 			</div>
 		</div>
 	</div>
diff --git a/website/source/intro/getting-started/build-image.html.markdown b/website/source/intro/getting-started/build-image.html.markdown
index 158733bb9..024447c78 100644
--- a/website/source/intro/getting-started/build-image.html.markdown
+++ b/website/source/intro/getting-started/build-image.html.markdown
@@ -4,6 +4,8 @@ page_title: "Build an Image"
 prev_url: "/intro/getting-started/setup.html"
 next_url: "/intro/getting-started/provision.html"
 next_title: "Provision"
+description: |-
+  With Packer installed, let's just dive right into it and build our first image. Our first image will be an Amazon EC2 AMI with Redis pre-installed. This is just an example. Packer can create images for many platforms with anything pre-installed.
 ---
 
 # Build an Image
@@ -19,12 +21,9 @@ qualifies under the AWS [free-tier](http://aws.amazon.com/free/), meaning
 it will be free. If you already have an AWS account, you may be charged some
 amount of money, but it shouldn't be more than a few cents.
 
-<div class="alert alert-block alert-warn">
-<strong>Note</strong> that if you're not using an account that qualifies under
-the AWS <a href="http://aws.amazon.com/free/">free-tier</a>, you may be
-charged to run these examples. The charge should only be a few cents, but
-we're not responsible if it ends up being more.
-</div>
+-> **Note:** If you're not using an account that qualifies under the AWS
+free-tier, you may be charged to run these examples. The charge should only be
+a few cents, but we're not responsible if it ends up being more.
 
 Packer can build images for [many platforms](/intro/platforms.html) other than
 AWS, but AWS requires no additional software installed on your computer and
@@ -44,7 +43,7 @@ as machine generated templates to easily be made.
 We'll start by creating the entire template, then we'll go over each section
 briefly. Create a file `example.json` and fill it with the following contents:
 
-<pre class="prettyprint">
+```javascript
 {
   "variables": {
     "aws_access_key": "",
@@ -61,7 +60,7 @@ briefly. Create a file `example.json` and fill it with the following contents:
     "ami_name": "packer-example {{timestamp}}"
   }]
 }
-</pre>
+```
 
 When building, you'll pass in the `aws_access_key` and `aws_secret_key` as
 a [user variable](/docs/templates/user-variables.html), keeping your secret
@@ -91,7 +90,7 @@ as well as the configuration values to verify they look valid. The output should
 look similar to below, because the template should be valid. If there are
 any errors, this command will tell you.
 
-```
+```text
 $ packer validate example.json
 Template validated successfully.
 ```
@@ -111,7 +110,7 @@ This is done by calling `packer build` with the template file. The output
 should look similar to below. Note that this process typically takes a
 few minutes.
 
-```
+```text
 $ packer build \
     -var 'aws_access_key=YOUR ACCESS KEY' \
     -var 'aws_secret_key=YOUR SECRET KEY' \
@@ -149,12 +148,10 @@ we only have a single artifact: the AMI in us-east-1 that was created.
 This AMI is ready to use. If you wanted you can go and launch this AMI
 right now and it would work great.
 
-<div class="alert alert-block alert-info">
-<strong>Note:</strong> Your AMI ID will surely be different than the
+-> **Note:** Your AMI ID will surely be different than the
 one above. If you try to launch the one in the example output above, you
 will get an error. If you want to try to launch your AMI, get the ID from
 the Packer output.
-</div>
 
 ## Managing the Image
 
diff --git a/website/source/intro/getting-started/next.html.markdown b/website/source/intro/getting-started/next.html.markdown
index eee743fc9..11f5ea4f7 100644
--- a/website/source/intro/getting-started/next.html.markdown
+++ b/website/source/intro/getting-started/next.html.markdown
@@ -1,6 +1,8 @@
 ---
 layout: "intro"
 page_title: "Next Steps"
+description: |-
+  That concludes the getting started guide for Packer. You should now be comfortable with basic Packer usage, should understand templates, defining builds, provisioners, etc. At this point you're ready to begin playing with and using Packer in real scenarios.
 ---
 
 # Next Steps
diff --git a/website/source/intro/getting-started/parallel-builds.html.markdown b/website/source/intro/getting-started/parallel-builds.html.markdown
index e51311214..72ab4737c 100644
--- a/website/source/intro/getting-started/parallel-builds.html.markdown
+++ b/website/source/intro/getting-started/parallel-builds.html.markdown
@@ -4,6 +4,8 @@ page_title: "Parallel Builds"
 prev_url: "/intro/getting-started/provision.html"
 next_url: "/intro/getting-started/vagrant.html"
 next_title: "Vagrant Boxes"
+description: |-
+  So far we've shown how Packer can automatically build an image and provision it. This on its own is already quite powerful. But Packer can do better than that. Packer can create multiple images for multiple platforms in parallel, all configured from a single template.
 ---
 
 # Parallel Builds
@@ -44,11 +46,8 @@ to sign up. Because the "droplets" (servers) are charged hourly, you
 _will_ be charged $0.01 for every image you create with Packer. If
 you're not okay with this, just follow along.
 
-<div class="alert alert-block alert-warn">
-<strong>Note!</strong> I want to repeat, in case you didn't see above:
-You <em>will</em> be charged $0.01 by DigitalOcean per image created with Packer
-because of the time the "droplet" is running.
-</div>
+!> **Warning!** You _will_ be charged $0.01 by DigitalOcean per image
+created with Packer because of the time the "droplet" is running.
 
 Once you sign up for an account, grab your client ID and API key from
 the [DigitalOcean API access page](https://www.digitalocean.com/api_access).
@@ -60,24 +59,24 @@ We now have to modify the template to add DigitalOcean to it. Modify the
 template we've been using and add the following JSON object to the `builders`
 array.
 
-<pre class="prettyprint">
+```javascript
 {
   "type": "digitalocean",
   "api_key": "{{user `do_api_key`}}",
   "client_id": "{{user `do_client_id`}}"
 }
-</pre>
+```
 
 You'll also need to modify the `variables` section of the template
 to include the access keys for DigitalOcean.
 
-<pre class="prettyprint">
+```javascript
 "variables": {
-  ...
   "do_api_key": "",
   "do_client_id": ""
+  // ...
 }
-</pre>
+```
 
 The entire template should now [look like this](https://gist.github.com/pearkes/cc5f8505eee5403a43a6).
 
@@ -88,12 +87,11 @@ you can do that as well.
 
 Validate the template with `packer validate`. This is always a good practice.
 
-<div class="alert alert-block alert-info">
-<strong>If you're looking for more DigitalOcean configuration options</strong>,
-you can find them on the <a href="/docs/builders/digitalocean.html">DigitalOcean
-Builder page</a> in the documentation. The documentation is more of a reference
-manual that contains a listing of all the available configuration options.
-</div>
+-> **Note:** If you're looking for more **DigitalOcean configuration options**,
+you can find them on the
+[DigitalOcean Builder page](/docs/builders/digitalocean.html) in the
+documentation. The documentation is more of a reference manual that contains a
+listing of all the available configuration options.
 
 ## Build
 
@@ -102,7 +100,7 @@ all of it, but a portion of it is reproduced below. Note that the ordering
 and wording of the lines may be slightly different, but the effect is the
 same.
 
-```
+```text
 $ packer build \
     -var 'aws_access_key=YOUR ACCESS KEY' \
     -var 'aws_secret_key=YOUR SECRET KEY' \
diff --git a/website/source/intro/getting-started/provision.html.markdown b/website/source/intro/getting-started/provision.html.markdown
index 4276ae089..bedb63b69 100644
--- a/website/source/intro/getting-started/provision.html.markdown
+++ b/website/source/intro/getting-started/provision.html.markdown
@@ -4,6 +4,8 @@ page_title: "Provision"
 prev_url: "/intro/getting-started/build-image.html"
 next_url: "/intro/getting-started/parallel-builds.html"
 next_title: "Parallel Builds"
+description: |-
+  In the previous page of this guide, you created your first image with Packer. The image you just built, however, was basically just a repackaging of a previously existing base AMI. The real utility of Packer comes from being able to install and configure software into the images as well. This stage is also known as the _provision_ step. Packer fully supports automated provisioning in order to install software onto the machines prior to turning them into images.
 ---
 
 # Provision
@@ -35,10 +37,10 @@ shell provisioner that comes with Packer to install Redis. Modify the
 explain the various parts of the new configuration following the code
 block below.
 
-<pre class="prettyprint">
+```javascript
 {
-  "variables": [...],
-  "builders": [...],
+  "variables": ["..."],
+  "builders": ["..."],
 
   "provisioners": [{
     "type": "shell",
@@ -49,18 +51,17 @@ block below.
     ]
   }]
 }
-</pre>
+```
 
-<div class="alert alert-block alert-info">
-<strong>Note:</strong> The <code>sleep 30</code> in the example above is
+-> **Note:** The `sleep 30` in the example above is
 very important. Because Packer is able to detect and SSH into the instance
 as soon as SSH is available, Ubuntu actually doesn't get proper amounts
 of time to initialize. The sleep makes sure that the OS properly initializes.
-</div>
 
 Hopefully it is obvious, but the `builders` section shouldn't actually
 contain "...", it should be the contents setup in the previous page
-of the getting started guide.
+of the getting started guide. Also note the comma after the `"builders": [...]`
+section, which was not present in the previous lesson.
 
 To configure the provisioners, we add a new section `provisioners` to the
 template, alongside the `builders` configuration. The provisioners section
diff --git a/website/source/intro/getting-started/setup.html.markdown b/website/source/intro/getting-started/setup.html.markdown
index 276f1d9c8..60eed6df8 100644
--- a/website/source/intro/getting-started/setup.html.markdown
+++ b/website/source/intro/getting-started/setup.html.markdown
@@ -4,6 +4,8 @@ page_title: "Install Packer"
 prev_url: "/intro/platforms.html"
 next_url: "/intro/getting-started/build-image.html"
 next_title: "Build an Image"
+description: |-
+  Packer must first be installed on the machine you want to run it on. To make installation easy, Packer is distributed as a binary package for all supported platforms and architectures. This page will not cover how to compile Packer from source, as that is covered in the README and is only recommended for advanced users.
 ---
 
 # Install Packer
@@ -39,13 +41,13 @@ contains instructions for setting the PATH on Windows.
 After installing Packer, verify the installation worked by opening
 a new command prompt or console, and checking that `packer` is available:
 
-```
+```text
 $ packer
 usage: packer [--version] [--help] <command> [<args>]
 
 Available commands are:
     build        build image(s) from template
-    fix           fixes templates from old versions of packer
+    fix          fixes templates from old versions of packer
     inspect      see components of a template
     validate     check that a template is valid
 ```
@@ -66,7 +68,7 @@ are alternatives available.
 If you're using OS X and [Homebrew](http://brew.sh), you can install Packer by
 adding the `binary` tap:
 
-```
+```text
 $ brew tap homebrew/binary
 $ brew install packer
 ```
diff --git a/website/source/intro/getting-started/vagrant.html.markdown b/website/source/intro/getting-started/vagrant.html.markdown
index dcca867aa..7353c6f0b 100644
--- a/website/source/intro/getting-started/vagrant.html.markdown
+++ b/website/source/intro/getting-started/vagrant.html.markdown
@@ -4,6 +4,8 @@ page_title: "Vagrant Boxes"
 prev_url: "/intro/getting-started/parallel-builds.html"
 next_url: "/intro/getting-started/next.html"
 next_title: "Next Steps"
+description: |-
+  Packer also has the ability to take the results of a builder (such as an AMI or plain VMware image) and turn it into a Vagrant box.
 ---
 
 # Vagrant Boxes
@@ -33,15 +35,13 @@ Post-processors are added in the `post-processors` section of a template, which
 we haven't created yet. Modify your `example.json` template and add the section.
 Your template should look like the following:
 
-<pre class="prettyprint">
+```javascript
 {
-  "builders": [...],
-
-  "provisioners": [...],
-
+  "builders": ["..."],
+  "provisioners": ["..."],
   "post-processors": ["vagrant"]
 }
-</pre>
+```
 
 In this case, we're enabling a single post-processor named "vagrant". This
 post-processor is built-in to Packer and will create Vagrant boxes. You
@@ -58,7 +58,7 @@ Since Packer can't currently make a Vagrant box for DigitalOcean anyways,
 I recommend passing the `-only=amazon-ebs` flag to `packer build` so it only
 builds the AMI. The command should look like the following:
 
-```
+```text
 $ packer build -only=amazon-ebs example.json
 ```
 
diff --git a/website/source/intro/index.html.markdown b/website/source/intro/index.html.markdown
index 381982f81..147cc51ee 100644
--- a/website/source/intro/index.html.markdown
+++ b/website/source/intro/index.html.markdown
@@ -4,6 +4,8 @@ page_title: "Introduction"
 prev_url: "#"
 next_url: "/intro/why.html"
 next_title: "Why Use Packer?"
+description: |-
+  Welcome to the world of Packer! This introduction guide will show you what Packer is, explain why it exists, the benefits it has to offer, and how you can get started with it. If you're already familiar with Packer, the documentation provides more of a reference for all available features.
 ---
 
 # Introduction to Packer
diff --git a/website/source/intro/platforms.html.markdown b/website/source/intro/platforms.html.markdown
index dfe8cd96b..75fcf6721 100644
--- a/website/source/intro/platforms.html.markdown
+++ b/website/source/intro/platforms.html.markdown
@@ -4,25 +4,25 @@ page_title: "Supported Platforms"
 prev_url: "/intro/use-cases.html"
 next_url: "/intro/getting-started/setup.html"
 next_title: "Getting Started: Install Packer"
+description: |-
+  Packer can create machine images for any platform. Packer ships with support for a set of platforms, but can be extended through plugins to support any platform. This page documents the list of supported image types that Packer supports creating.
 ---
 
 # Supported Platforms
 
 Packer can create machine images for any platform. Packer ships with
-support for a set of platforms, but can be [extend through plugins](/docs/extend/builder.html)
+support for a set of platforms, but can be [extended through plugins](/docs/extend/builder.html)
 to support any platform. This page documents the list of supported image
 types that Packer supports creating.
 
 If you were looking to see what platforms Packer is able to run on, see
 the page on [installing Packer](/intro/getting-started/setup.html).
 
-<div class="alert alert-info alert-block">
-<strong>Note:</strong> We're always looking to officially support more
+-> **Note:** We're always looking to officially support more
 target platforms. If you're interested in adding support for another
 platform, please help by opening an issue or pull request within
-<a href="https://github.com/mitchellh/packer">GitHub</a> so we can discuss
+[GitHub](https://github.com/mitchellh/packer) so we can discuss
 how to make it happen.
-</div>
 
 Packer supports creating images for the following platforms or targets.
 The format of the resulting image and any high-level information about the
@@ -30,31 +30,35 @@ platform is noted. They are listed in alphabetical order. For more detailed
 information on supported configuration parameters and usage, please see
 the appropriate [documentation page within the documentation section](/docs).
 
-* ***Amazon EC2 (AMI)***. Both EBS-backed and instance-store AMIs within EC2,
-  optionally distributed to multiple regions.
+* ***Amazon EC2 (AMI)***. Both EBS-backed and instance-store AMIs within
+  [EC2](http://aws.amazon.com/ec2/), optionally distributed to multiple regions.
 
-* ***DigitalOcean***. Snapshots for [DigitalOcean](http://www.digitalocean.com)
+* ***DigitalOcean***. Snapshots for [DigitalOcean](http://www.digitalocean.com/)
   that can be used to start a pre-configured DigitalOcean instance of any size.
 
-* ***Docker***. Snapshots for [Docker](http://www.docker.io)
+* ***Docker***. Snapshots for [Docker](http://www.docker.io/)
   that can be used to start a pre-configured Docker instance.
 
 * ***Google Compute Engine***. Snapshots for [Google Compute Engine](https://cloud.google.com/products/compute-engine)
   that can be used to start a pre-configured Google Compute Engine instance.
 
-* ***OpenStack***. Images for [OpenStack](http://www.openstack.org)
+* ***OpenStack***. Images for [OpenStack](http://www.openstack.org/)
   that can be used to start pre-configured OpenStack servers.
 
+* ***Parallels (PVM)***. Exported virtual machines for [Parallels](http://www.parallels.com/downloads/desktop/),
+  including virtual machine metadata such as RAM, CPUs, etc. These virtual
+  machines are portable and can be started on any platform Parallels runs on.
+
 * ***QEMU***. Images for [KVM](http://www.linux-kvm.org/) or [Xen](http://www.xenproject.org/)
   that can be used to start pre-configured KVM or Xen instances.
 
-* ***VirtualBox (OVF)***. Exported virtual machines for VirtualBox, including
-  virtual machine metadata such as RAM, CPUs, etc. These virtual machines are
-  portable and can be started on any platform VirtualBox runs on.
+* ***VirtualBox (OVF)***. Exported virtual machines for [VirtualBox](https://www.virtualbox.org/),
+  including virtual machine metadata such as RAM, CPUs, etc. These virtual
+  machines are portable and can be started on any platform VirtualBox runs on.
 
-* ***VMware (VMX)***. Exported virtual machines for VMware that can be run
-  within any desktop products such as Fusion, Player, or Workstation, as well
-  as server products such as vSphere.
+* ***VMware (VMX)***. Exported virtual machines for [VMware](http://www.vmware.com/)
+  that can be run within any desktop products such as Fusion, Player, or
+  Workstation, as well as server products such as vSphere.
 
 As previously mentioned, these are just the target image types that Packer
 ships with out of the box. You can always [extend Packer through plugins](/docs/extend/builder.html)
diff --git a/website/source/intro/use-cases.html.markdown b/website/source/intro/use-cases.html.markdown
index 18e95c999..0b73ea32c 100644
--- a/website/source/intro/use-cases.html.markdown
+++ b/website/source/intro/use-cases.html.markdown
@@ -4,6 +4,8 @@ page_title: "Use Cases"
 prev_url: "/intro/why.html"
 next_url: "/intro/platforms.html"
 next_title: "Supported Platforms"
+description: |-
+  By now you should know what Packer does and what the benefits of image creation are. In this section, we'll enumerate _some_ of the use cases for Packer. Note that this is not an exhaustive list by any means. There are definitely use cases for Packer not listed here. This list is just meant to give you an idea of how Packer may improve your processes.
 ---
 
 # Use Cases
diff --git a/website/source/intro/why.html.markdown b/website/source/intro/why.html.markdown
index cf999fb47..98de7855f 100644
--- a/website/source/intro/why.html.markdown
+++ b/website/source/intro/why.html.markdown
@@ -4,6 +4,8 @@ page_title: "Why Use Packer?"
 prev_url: "/intro/index.html"
 next_url: "/intro/use-cases.html"
 next_title: "Packer Use Cases"
+description: |-
+  Pre-baked machine images have a lot of advantages, but most have been unable to benefit from them because images have been too tedious to create and manage. There were either no existing tools to automate the creation of machine images or they had too high of a learning curve. The result is that, prior to Packer, creating machine images threatened the agility of operations teams, and therefore aren't used, despite the massive benefits.
 ---
 
 # Why Use Packer?
diff --git a/website/source/javascripts/lang-go.js b/website/source/javascripts/lang-go.js
deleted file mode 100644
index f329e29b3..000000000
--- a/website/source/javascripts/lang-go.js
+++ /dev/null
@@ -1,58 +0,0 @@
-// Copyright (C) 2010 Google Inc.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//      http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-
-
-/**
- * @fileoverview
- * Registers a language handler for the Go language..
- * <p>
- * Based on the lexical grammar at 
- * http://golang.org/doc/go_spec.html#Lexical_elements
- * <p>
- * Go uses a minimal style for highlighting so the below does not distinguish
- * strings, keywords, literals, etc. by design.
- * From a discussion with the Go designers:
- * <pre>
- * On Thursday, July 22, 2010, Mike Samuel <...> wrote:
- * > On Thu, Jul 22, 2010, Rob 'Commander' Pike <...> wrote:
- * >> Personally, I would vote for the subdued style godoc presents at http://golang.org
- * >>
- * >> Not as fancy as some like, but a case can be made it's the official style.
- * >> If people want more colors, I wouldn't fight too hard, in the interest of
- * >> encouragement through familiarity, but even then I would ask to shy away
- * >> from technicolor starbursts.
- * >
- * > Like http://golang.org/pkg/go/scanner/ where comments are blue and all
- * > other content is black?  I can do that.
- * </pre>
- *
- * @author mikesamuel@gmail.com
- */
-
-PR['registerLangHandler'](
-    PR['createSimpleLexer'](
-        [
-         // Whitespace is made up of spaces, tabs and newline characters.
-         [PR['PR_PLAIN'],       /^[\t\n\r \xA0]+/, null, '\t\n\r \xA0'],
-         // Not escaped as a string.  See note on minimalism above.
-         [PR['PR_PLAIN'],       /^(?:\"(?:[^\"\\]|\\[\s\S])*(?:\"|$)|\'(?:[^\'\\]|\\[\s\S])+(?:\'|$)|`[^`]*(?:`|$))/, null, '"\'']
-        ],
-        [
-         // Block comments are delimited by /* and */.
-         // Single-line comments begin with // and extend to the end of a line.
-         [PR['PR_COMMENT'],     /^(?:\/\/[^\r\n]*|\/\*[\s\S]*?\*\/)/],
-         [PR['PR_PLAIN'],       /^(?:[^\/\"\'`]|\/(?![\/\*]))+/i]
-        ]),
-    ['go']);
diff --git a/website/source/javascripts/prettify.js b/website/source/javascripts/prettify.js
deleted file mode 100644
index 7b990496d..000000000
--- a/website/source/javascripts/prettify.js
+++ /dev/null
@@ -1,30 +0,0 @@
-!function(){var q=null;window.PR_SHOULD_USE_CONTINUATION=!0;
-(function(){function S(a){function d(e){var b=e.charCodeAt(0);if(b!==92)return b;var a=e.charAt(1);return(b=r[a])?b:"0"<=a&&a<="7"?parseInt(e.substring(1),8):a==="u"||a==="x"?parseInt(e.substring(2),16):e.charCodeAt(1)}function g(e){if(e<32)return(e<16?"\\x0":"\\x")+e.toString(16);e=String.fromCharCode(e);return e==="\\"||e==="-"||e==="]"||e==="^"?"\\"+e:e}function b(e){var b=e.substring(1,e.length-1).match(/\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\[0-3][0-7]{0,2}|\\[0-7]{1,2}|\\[\S\s]|[^\\]/g),e=[],a=
-b[0]==="^",c=["["];a&&c.push("^");for(var a=a?1:0,f=b.length;a<f;++a){var h=b[a];if(/\\[bdsw]/i.test(h))c.push(h);else{var h=d(h),l;a+2<f&&"-"===b[a+1]?(l=d(b[a+2]),a+=2):l=h;e.push([h,l]);l<65||h>122||(l<65||h>90||e.push([Math.max(65,h)|32,Math.min(l,90)|32]),l<97||h>122||e.push([Math.max(97,h)&-33,Math.min(l,122)&-33]))}}e.sort(function(e,a){return e[0]-a[0]||a[1]-e[1]});b=[];f=[];for(a=0;a<e.length;++a)h=e[a],h[0]<=f[1]+1?f[1]=Math.max(f[1],h[1]):b.push(f=h);for(a=0;a<b.length;++a)h=b[a],c.push(g(h[0])),
-h[1]>h[0]&&(h[1]+1>h[0]&&c.push("-"),c.push(g(h[1])));c.push("]");return c.join("")}function s(e){for(var a=e.source.match(/\[(?:[^\\\]]|\\[\S\s])*]|\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\\d+|\\[^\dux]|\(\?[!:=]|[()^]|[^()[\\^]+/g),c=a.length,d=[],f=0,h=0;f<c;++f){var l=a[f];l==="("?++h:"\\"===l.charAt(0)&&(l=+l.substring(1))&&(l<=h?d[l]=-1:a[f]=g(l))}for(f=1;f<d.length;++f)-1===d[f]&&(d[f]=++x);for(h=f=0;f<c;++f)l=a[f],l==="("?(++h,d[h]||(a[f]="(?:")):"\\"===l.charAt(0)&&(l=+l.substring(1))&&l<=h&&
-(a[f]="\\"+d[l]);for(f=0;f<c;++f)"^"===a[f]&&"^"!==a[f+1]&&(a[f]="");if(e.ignoreCase&&m)for(f=0;f<c;++f)l=a[f],e=l.charAt(0),l.length>=2&&e==="["?a[f]=b(l):e!=="\\"&&(a[f]=l.replace(/[A-Za-z]/g,function(a){a=a.charCodeAt(0);return"["+String.fromCharCode(a&-33,a|32)+"]"}));return a.join("")}for(var x=0,m=!1,j=!1,k=0,c=a.length;k<c;++k){var i=a[k];if(i.ignoreCase)j=!0;else if(/[a-z]/i.test(i.source.replace(/\\u[\da-f]{4}|\\x[\da-f]{2}|\\[^UXux]/gi,""))){m=!0;j=!1;break}}for(var r={b:8,t:9,n:10,v:11,
-f:12,r:13},n=[],k=0,c=a.length;k<c;++k){i=a[k];if(i.global||i.multiline)throw Error(""+i);n.push("(?:"+s(i)+")")}return RegExp(n.join("|"),j?"gi":"g")}function T(a,d){function g(a){var c=a.nodeType;if(c==1){if(!b.test(a.className)){for(c=a.firstChild;c;c=c.nextSibling)g(c);c=a.nodeName.toLowerCase();if("br"===c||"li"===c)s[j]="\n",m[j<<1]=x++,m[j++<<1|1]=a}}else if(c==3||c==4)c=a.nodeValue,c.length&&(c=d?c.replace(/\r\n?/g,"\n"):c.replace(/[\t\n\r ]+/g," "),s[j]=c,m[j<<1]=x,x+=c.length,m[j++<<1|1]=
-a)}var b=/(?:^|\s)nocode(?:\s|$)/,s=[],x=0,m=[],j=0;g(a);return{a:s.join("").replace(/\n$/,""),d:m}}function H(a,d,g,b){d&&(a={a:d,e:a},g(a),b.push.apply(b,a.g))}function U(a){for(var d=void 0,g=a.firstChild;g;g=g.nextSibling)var b=g.nodeType,d=b===1?d?a:g:b===3?V.test(g.nodeValue)?a:d:d;return d===a?void 0:d}function C(a,d){function g(a){for(var j=a.e,k=[j,"pln"],c=0,i=a.a.match(s)||[],r={},n=0,e=i.length;n<e;++n){var z=i[n],w=r[z],t=void 0,f;if(typeof w==="string")f=!1;else{var h=b[z.charAt(0)];
-if(h)t=z.match(h[1]),w=h[0];else{for(f=0;f<x;++f)if(h=d[f],t=z.match(h[1])){w=h[0];break}t||(w="pln")}if((f=w.length>=5&&"lang-"===w.substring(0,5))&&!(t&&typeof t[1]==="string"))f=!1,w="src";f||(r[z]=w)}h=c;c+=z.length;if(f){f=t[1];var l=z.indexOf(f),B=l+f.length;t[2]&&(B=z.length-t[2].length,l=B-f.length);w=w.substring(5);H(j+h,z.substring(0,l),g,k);H(j+h+l,f,I(w,f),k);H(j+h+B,z.substring(B),g,k)}else k.push(j+h,w)}a.g=k}var b={},s;(function(){for(var g=a.concat(d),j=[],k={},c=0,i=g.length;c<i;++c){var r=
-g[c],n=r[3];if(n)for(var e=n.length;--e>=0;)b[n.charAt(e)]=r;r=r[1];n=""+r;k.hasOwnProperty(n)||(j.push(r),k[n]=q)}j.push(/[\S\s]/);s=S(j)})();var x=d.length;return g}function v(a){var d=[],g=[];a.tripleQuotedStrings?d.push(["str",/^(?:'''(?:[^'\\]|\\[\S\s]|''?(?=[^']))*(?:'''|$)|"""(?:[^"\\]|\\[\S\s]|""?(?=[^"]))*(?:"""|$)|'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$))/,q,"'\""]):a.multiLineStrings?d.push(["str",/^(?:'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$)|`(?:[^\\`]|\\[\S\s])*(?:`|$))/,
-q,"'\"`"]):d.push(["str",/^(?:'(?:[^\n\r'\\]|\\.)*(?:'|$)|"(?:[^\n\r"\\]|\\.)*(?:"|$))/,q,"\"'"]);a.verbatimStrings&&g.push(["str",/^@"(?:[^"]|"")*(?:"|$)/,q]);var b=a.hashComments;b&&(a.cStyleComments?(b>1?d.push(["com",/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,q,"#"]):d.push(["com",/^#(?:(?:define|e(?:l|nd)if|else|error|ifn?def|include|line|pragma|undef|warning)\b|[^\n\r]*)/,q,"#"]),g.push(["str",/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h(?:h|pp|\+\+)?|[a-z]\w*)>/,q])):d.push(["com",
-/^#[^\n\r]*/,q,"#"]));a.cStyleComments&&(g.push(["com",/^\/\/[^\n\r]*/,q]),g.push(["com",/^\/\*[\S\s]*?(?:\*\/|$)/,q]));if(b=a.regexLiterals){var s=(b=b>1?"":"\n\r")?".":"[\\S\\s]";g.push(["lang-regex",RegExp("^(?:^^\\.?|[+-]|[!=]=?=?|\\#|%=?|&&?=?|\\(|\\*=?|[+\\-]=|->|\\/=?|::?|<<?=?|>>?>?=?|,|;|\\?|@|\\[|~|{|\\^\\^?=?|\\|\\|?=?|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\\s*("+("/(?=[^/*"+b+"])(?:[^/\\x5B\\x5C"+b+"]|\\x5C"+s+"|\\x5B(?:[^\\x5C\\x5D"+b+"]|\\x5C"+
-s+")*(?:\\x5D|$))+/")+")")])}(b=a.types)&&g.push(["typ",b]);b=(""+a.keywords).replace(/^ | $/g,"");b.length&&g.push(["kwd",RegExp("^(?:"+b.replace(/[\s,]+/g,"|")+")\\b"),q]);d.push(["pln",/^\s+/,q," \r\n\t\u00a0"]);b="^.[^\\s\\w.$@'\"`/\\\\]*";a.regexLiterals&&(b+="(?!s*/)");g.push(["lit",/^@[$_a-z][\w$@]*/i,q],["typ",/^(?:[@_]?[A-Z]+[a-z][\w$@]*|\w+_t\b)/,q],["pln",/^[$_a-z][\w$@]*/i,q],["lit",/^(?:0x[\da-f]+|(?:\d(?:_\d+)*\d*(?:\.\d*)?|\.\d\+)(?:e[+-]?\d+)?)[a-z]*/i,q,"0123456789"],["pln",/^\\[\S\s]?/,
-q],["pun",RegExp(b),q]);return C(d,g)}function J(a,d,g){function b(a){var c=a.nodeType;if(c==1&&!x.test(a.className))if("br"===a.nodeName)s(a),a.parentNode&&a.parentNode.removeChild(a);else for(a=a.firstChild;a;a=a.nextSibling)b(a);else if((c==3||c==4)&&g){var d=a.nodeValue,i=d.match(m);if(i)c=d.substring(0,i.index),a.nodeValue=c,(d=d.substring(i.index+i[0].length))&&a.parentNode.insertBefore(j.createTextNode(d),a.nextSibling),s(a),c||a.parentNode.removeChild(a)}}function s(a){function b(a,c){var d=
-c?a.cloneNode(!1):a,e=a.parentNode;if(e){var e=b(e,1),g=a.nextSibling;e.appendChild(d);for(var i=g;i;i=g)g=i.nextSibling,e.appendChild(i)}return d}for(;!a.nextSibling;)if(a=a.parentNode,!a)return;for(var a=b(a.nextSibling,0),d;(d=a.parentNode)&&d.nodeType===1;)a=d;c.push(a)}for(var x=/(?:^|\s)nocode(?:\s|$)/,m=/\r\n?|\n/,j=a.ownerDocument,k=j.createElement("li");a.firstChild;)k.appendChild(a.firstChild);for(var c=[k],i=0;i<c.length;++i)b(c[i]);d===(d|0)&&c[0].setAttribute("value",d);var r=j.createElement("ol");
-r.className="linenums";for(var d=Math.max(0,d-1|0)||0,i=0,n=c.length;i<n;++i)k=c[i],k.className="L"+(i+d)%10,k.firstChild||k.appendChild(j.createTextNode("\u00a0")),r.appendChild(k);a.appendChild(r)}function p(a,d){for(var g=d.length;--g>=0;){var b=d[g];F.hasOwnProperty(b)?D.console&&console.warn("cannot override language handler %s",b):F[b]=a}}function I(a,d){if(!a||!F.hasOwnProperty(a))a=/^\s*</.test(d)?"default-markup":"default-code";return F[a]}function K(a){var d=a.h;try{var g=T(a.c,a.i),b=g.a;
-a.a=b;a.d=g.d;a.e=0;I(d,b)(a);var s=/\bMSIE\s(\d+)/.exec(navigator.userAgent),s=s&&+s[1]<=8,d=/\n/g,x=a.a,m=x.length,g=0,j=a.d,k=j.length,b=0,c=a.g,i=c.length,r=0;c[i]=m;var n,e;for(e=n=0;e<i;)c[e]!==c[e+2]?(c[n++]=c[e++],c[n++]=c[e++]):e+=2;i=n;for(e=n=0;e<i;){for(var p=c[e],w=c[e+1],t=e+2;t+2<=i&&c[t+1]===w;)t+=2;c[n++]=p;c[n++]=w;e=t}c.length=n;var f=a.c,h;if(f)h=f.style.display,f.style.display="none";try{for(;b<k;){var l=j[b+2]||m,B=c[r+2]||m,t=Math.min(l,B),A=j[b+1],G;if(A.nodeType!==1&&(G=x.substring(g,
-t))){s&&(G=G.replace(d,"\r"));A.nodeValue=G;var L=A.ownerDocument,o=L.createElement("span");o.className=c[r+1];var v=A.parentNode;v.replaceChild(o,A);o.appendChild(A);g<l&&(j[b+1]=A=L.createTextNode(x.substring(t,l)),v.insertBefore(A,o.nextSibling))}g=t;g>=l&&(b+=2);g>=B&&(r+=2)}}finally{if(f)f.style.display=h}}catch(u){D.console&&console.log(u&&u.stack||u)}}var D=window,y=["break,continue,do,else,for,if,return,while"],E=[[y,"auto,case,char,const,default,double,enum,extern,float,goto,inline,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"],
-"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"],M=[E,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,delegate,dynamic_cast,explicit,export,friend,generic,late_check,mutable,namespace,nullptr,property,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"],N=[E,"abstract,assert,boolean,byte,extends,final,finally,implements,import,instanceof,interface,null,native,package,strictfp,super,synchronized,throws,transient"],
-O=[N,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,internal,into,is,let,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var,virtual,where"],E=[E,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"],P=[y,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"],
-Q=[y,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"],W=[y,"as,assert,const,copy,drop,enum,extern,fail,false,fn,impl,let,log,loop,match,mod,move,mut,priv,pub,pure,ref,self,static,struct,true,trait,type,unsafe,use"],y=[y,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"],R=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)\b/,
-V=/\S/,X=v({keywords:[M,O,E,"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",P,Q,y],hashComments:!0,cStyleComments:!0,multiLineStrings:!0,regexLiterals:!0}),F={};p(X,["default-code"]);p(C([],[["pln",/^[^<?]+/],["dec",/^<!\w[^>]*(?:>|$)/],["com",/^<\!--[\S\s]*?(?:--\>|$)/],["lang-",/^<\?([\S\s]+?)(?:\?>|$)/],["lang-",/^<%([\S\s]+?)(?:%>|$)/],["pun",/^(?:<[%?]|[%?]>)/],["lang-",
-/^<xmp\b[^>]*>([\S\s]+?)<\/xmp\b[^>]*>/i],["lang-js",/^<script\b[^>]*>([\S\s]*?)(<\/script\b[^>]*>)/i],["lang-css",/^<style\b[^>]*>([\S\s]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),["default-markup","htm","html","mxml","xhtml","xml","xsl"]);p(C([["pln",/^\s+/,q," \t\r\n"],["atv",/^(?:"[^"]*"?|'[^']*'?)/,q,"\"'"]],[["tag",/^^<\/?[a-z](?:[\w-.:]*\w)?|\/?>$/i],["atn",/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^\s"'>]*(?:[^\s"'/>]|\/(?=\s)))/],["pun",/^[/<->]+/],
-["lang-js",/^on\w+\s*=\s*"([^"]+)"/i],["lang-js",/^on\w+\s*=\s*'([^']+)'/i],["lang-js",/^on\w+\s*=\s*([^\s"'>]+)/i],["lang-css",/^style\s*=\s*"([^"]+)"/i],["lang-css",/^style\s*=\s*'([^']+)'/i],["lang-css",/^style\s*=\s*([^\s"'>]+)/i]]),["in.tag"]);p(C([],[["atv",/^[\S\s]+/]]),["uq.val"]);p(v({keywords:M,hashComments:!0,cStyleComments:!0,types:R}),["c","cc","cpp","cxx","cyc","m"]);p(v({keywords:"null,true,false"}),["json"]);p(v({keywords:O,hashComments:!0,cStyleComments:!0,verbatimStrings:!0,types:R}),
-["cs"]);p(v({keywords:N,cStyleComments:!0}),["java"]);p(v({keywords:y,hashComments:!0,multiLineStrings:!0}),["bash","bsh","csh","sh"]);p(v({keywords:P,hashComments:!0,multiLineStrings:!0,tripleQuotedStrings:!0}),["cv","py","python"]);p(v({keywords:"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",hashComments:!0,multiLineStrings:!0,regexLiterals:2}),["perl","pl","pm"]);p(v({keywords:Q,
-hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["rb","ruby"]);p(v({keywords:E,cStyleComments:!0,regexLiterals:!0}),["javascript","js"]);p(v({keywords:"all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,throw,true,try,unless,until,when,while,yes",hashComments:3,cStyleComments:!0,multilineStrings:!0,tripleQuotedStrings:!0,regexLiterals:!0}),["coffee"]);p(v({keywords:W,cStyleComments:!0,multilineStrings:!0}),["rc","rs","rust"]);
-p(C([],[["str",/^[\S\s]+/]]),["regex"]);var Y=D.PR={createSimpleLexer:C,registerLangHandler:p,sourceDecorator:v,PR_ATTRIB_NAME:"atn",PR_ATTRIB_VALUE:"atv",PR_COMMENT:"com",PR_DECLARATION:"dec",PR_KEYWORD:"kwd",PR_LITERAL:"lit",PR_NOCODE:"nocode",PR_PLAIN:"pln",PR_PUNCTUATION:"pun",PR_SOURCE:"src",PR_STRING:"str",PR_TAG:"tag",PR_TYPE:"typ",prettyPrintOne:D.prettyPrintOne=function(a,d,g){var b=document.createElement("div");b.innerHTML="<pre>"+a+"</pre>";b=b.firstChild;g&&J(b,g,!0);K({h:d,j:g,c:b,i:1});
-return b.innerHTML},prettyPrint:D.prettyPrint=function(a,d){function g(){for(var b=D.PR_SHOULD_USE_CONTINUATION?c.now()+250:Infinity;i<p.length&&c.now()<b;i++){for(var d=p[i],j=h,k=d;k=k.previousSibling;){var m=k.nodeType,o=(m===7||m===8)&&k.nodeValue;if(o?!/^\??prettify\b/.test(o):m!==3||/\S/.test(k.nodeValue))break;if(o){j={};o.replace(/\b(\w+)=([\w%+\-.:]+)/g,function(a,b,c){j[b]=c});break}}k=d.className;if((j!==h||e.test(k))&&!v.test(k)){m=!1;for(o=d.parentNode;o;o=o.parentNode)if(f.test(o.tagName)&&
-o.className&&e.test(o.className)){m=!0;break}if(!m){d.className+=" prettyprinted";m=j.lang;if(!m){var m=k.match(n),y;if(!m&&(y=U(d))&&t.test(y.tagName))m=y.className.match(n);m&&(m=m[1])}if(w.test(d.tagName))o=1;else var o=d.currentStyle,u=s.defaultView,o=(o=o?o.whiteSpace:u&&u.getComputedStyle?u.getComputedStyle(d,q).getPropertyValue("white-space"):0)&&"pre"===o.substring(0,3);u=j.linenums;if(!(u=u==="true"||+u))u=(u=k.match(/\blinenums\b(?::(\d+))?/))?u[1]&&u[1].length?+u[1]:!0:!1;u&&J(d,u,o);r=
-{h:m,c:d,j:u,i:o};K(r)}}}i<p.length?setTimeout(g,250):"function"===typeof a&&a()}for(var b=d||document.body,s=b.ownerDocument||document,b=[b.getElementsByTagName("pre"),b.getElementsByTagName("code"),b.getElementsByTagName("xmp")],p=[],m=0;m<b.length;++m)for(var j=0,k=b[m].length;j<k;++j)p.push(b[m][j]);var b=q,c=Date;c.now||(c={now:function(){return+new Date}});var i=0,r,n=/\blang(?:uage)?-([\w.]+)(?!\S)/,e=/\bprettyprint\b/,v=/\bprettyprinted\b/,w=/pre|xmp/i,t=/^code$/i,f=/^(?:pre|code|xmp)$/i,
-h={};g()}};typeof define==="function"&&define.amd&&define("google-code-prettify",[],function(){return Y})})();}()
diff --git a/website/source/layouts/docs.erb b/website/source/layouts/docs.erb
index 3c0bae143..b686bb515 100644
--- a/website/source/layouts/docs.erb
+++ b/website/source/layouts/docs.erb
@@ -34,7 +34,9 @@
 			<li><a href="/docs/builders/digitalocean.html">DigitalOcean</a></li>
 			<li><a href="/docs/builders/docker.html">Docker</a></li>
 			<li><a href="/docs/builders/googlecompute.html">Google Compute Engine</a></li>
+			<li><a href="/docs/builders/null.html">Null</a></li>
 			<li><a href="/docs/builders/openstack.html">OpenStack</a></li>
+			<li><a href="/docs/builders/parallels.html">Parallels</a></li>
 			<li><a href="/docs/builders/qemu.html">QEMU</a></li>
 			<li><a href="/docs/builders/virtualbox.html">VirtualBox</a></li>
 			<li><a href="/docs/builders/vmware.html">VMware</a></li>
@@ -56,9 +58,13 @@
 
 		<ul>
 			<li><h4>Post-Processors</h4></li>
+			<li><a href="/docs/post-processors/compress.html">compress</a></li>
 			<li><a href="/docs/post-processors/docker-import.html">docker-import</a></li>
 			<li><a href="/docs/post-processors/docker-push.html">docker-push</a></li>
+			<li><a href="/docs/post-processors/docker-save.html">docker-save</a></li>
+			<li><a href="/docs/post-processors/docker-tag.html">docker-tag</a></li>
 			<li><a href="/docs/post-processors/vagrant.html">Vagrant</a></li>
+			<li><a href="/docs/post-processors/vagrant-cloud.html">Vagrant Cloud</a></li>
 			<li><a href="/docs/post-processors/vsphere.html">vSphere</a></li>
 		</ul>
 
@@ -66,6 +72,7 @@
 			<li><h4>Other</h4></li>
 			<li><a href="/docs/other/core-configuration.html">Core Configuration</a></li>
 			<li><a href="/docs/other/debugging.html">Debugging</a></li>
+			<li><a href="/docs/other/environmental-variables.html">Environmental Variables</a></li>
 		</ul>
 
 		<ul>
diff --git a/website/source/layouts/inner.erb b/website/source/layouts/inner.erb
index cd486ad26..c570f73f6 100644
--- a/website/source/layouts/inner.erb
+++ b/website/source/layouts/inner.erb
@@ -1,33 +1,30 @@
 <% wrap_layout :layout do %>
-	<div class="docs-wrapper">
-		<div class="sidebar dark-background">
-			<%= yield_content :sidebar %>
+<div class="docs-wrapper">
+  <div class="row row-lg-height">
+    <div class="sidebar col-sm-3 col-md-3 col-lg-height col-md-height col-sm-height">
+      <%= yield_content :sidebar %>
+    </div>
+    <div class="docs-body col-sm-9 col-md-9 col-lg-height col-md-height col-sm-height">
+      <div class="docs-content">
+        <%= yield %>
+      </div>
 
-			<div class="sidebar-background"></div>
-		</div>
-
-		<div class="docs-body">
-			<div class="docs-content">
-				<%= yield %>
-			</div>
-
-			<% if current_page.data.next_url %>
-				<div class="pagination">
-					<a class="previous-section" href="<%= current_page.data.prev_url %>"></a>
-					<% if current_page.data.next_url == "" %>
-					<h4><span class="text-green uppercase">End</span></h4>
-					<% else %>
-					<a class="next-section" href="<%= current_page.data.next_url %>">
-						<h4>
-							<span class="text-green uppercase">next</span>
-							<%= current_page.data.next_title %>
-						</h4>
-					</a>
-					<% end %>
-				</div>
-			<% end %>
-
-			<div class="docs-background"></div>
-		</div>
-	</div>
+      <% if current_page.data.next_url %>
+        <div class="pagination">
+          <a class="previous-section" href="<%= current_page.data.prev_url %>"></a>
+          <% if current_page.data.next_url == "" %>
+          <h4><span class="text-green uppercase">End</span></h4>
+          <% else %>
+          <a class="next-section" href="<%= current_page.data.next_url %>">
+            <h4>
+              <span class="text-green uppercase">next</span>
+              <%= current_page.data.next_title %>
+            </h4>
+          </a>
+          <% end %>
+        </div>
+      <% end %>
+    </div>
+  </div>
+</div>
 <% end %>
diff --git a/website/source/layouts/layout.erb b/website/source/layouts/layout.erb
index e46e8305b..898de87c1 100644
--- a/website/source/layouts/layout.erb
+++ b/website/source/layouts/layout.erb
@@ -1,50 +1,27 @@
 <!DOCTYPE html>
 <html>
 	<head>
-		<title><%= current_page.data.page_title ? "#{current_page.data.page_title} - " : "" %>Packer</title>
-		<meta name="description" content="Packer is a free and open source tool for creating golden images for multiple platforms from a single source configuration." />
+		<title><%= [current_page.data.page_title, "Packer by HashiCorp"].compact.join(" - ") %></title>
+    <meta name="description" content="<%= current_page.data.description %>" />
 
-		<!-- HTML5 shiv -->
-		<!--[if lt IE 9]>
-		<script src="dist/html5shiv.js"></script>
-		<![endif]-->
+		<%= stylesheet_link_tag "application" %>
 
-		<!-- css -->
-		<%= stylesheet_link_tag "bootstrap.min", "main", "prettify" %>
-
-		<!-- js -->
-		<%= javascript_include_tag "prettify" %>
-
-		<!-- analytics -->
-		<script>
-			(function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
-					(i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
-				m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
-			})(window,document,'script','//www.google-analytics.com/analytics.js','ga');
-
-			ga('create', 'UA-43075859-1', 'packer.io');
-			ga('send', 'pageview');
-
-		</script>
-
-		<!-- fonts -->
-		<link href='http://fonts.googleapis.com/css?family=Inconsolata' rel='stylesheet' type='text/css'>
 		<script type="text/javascript" src="//use.typekit.net/apr3jjs.js"></script>
 		<script type="text/javascript">try{Typekit.load();}catch(e){}</script>
 	</head>
 	<body>
 		<nav class="dark-background">
 		<div class="container-fluid">
-			<div class="row-fluid">
-				<div class="span12">
-					<a href="https://github.com/mitchellh/packer">
-						<button class="download pull-right primary">GitHub</button>
-					</a>
-					<a href="/downloads.html">
-						<button class="download pull-right primary spaced">Download</button>
-					</a>
+			<div class="row">
+				<div class="col-md-12">
 					<a href="/" class="packer-logo pull-left">Packer</a>
 					<ul>
+            <li class="featured">
+              <a href="https://github.com/mitchellh/packer" class="primary">GitHub</a>
+            </li>
+            <li class="featured">
+              <a href="/downloads.html" class="primary">Download</a>
+            </li>
 						<li><a href="/intro">Intro</a></li>
 						<li><a href="/docs">Documentation</a></li>
 						<li><a href="/community">Community</a></li>
@@ -60,20 +37,30 @@
 
 		<footer class="dark-background">
 		<div class="container-fluid">
-			<div class="row-fluid">
-				<div class="span12">
+			<div class="row">
+				<div class="col-md-12">
 					<ul>
 						<li class="packer"><a href="/">Packer</a></li>
-						<li>A <a href="http://www.hashicorp.com/">HashiCorp</a> project.</li>
-						<a href="http://www.hashicorp.com">
-							<li class="pull-right hashi-logo">&nbps;</li>
-						</a>
+            <li>
+						  A <a href="http://www.hashicorp.com/">HashiCorp</a> project.
+            </li>
+					  <a href="http://www.hashicorp.com">
+						 <li class="pull-right hashi-logo">&nbps;</li>
+					  </a>
 					</ul>
 				</div>
 			</div>
 		</div>
 		</footer>
 
-		<script type="text/javascript">prettyPrint();</script>
+    <script>
+      (function(i,s,o,g,r,a,m){i['GoogleAnalyticsObject']=r;i[r]=i[r]||function(){
+          (i[r].q=i[r].q||[]).push(arguments)},i[r].l=1*new Date();a=s.createElement(o),
+        m=s.getElementsByTagName(o)[0];a.async=1;a.src=g;m.parentNode.insertBefore(a,m)
+      })(window,document,'script','//www.google-analytics.com/analytics.js','ga');
+
+      ga('create', 'UA-43075859-1', 'packer.io');
+      ga('send', 'pageview');
+    </script>
 	</body>
 </html>
diff --git a/website/source/robots.txt b/website/source/robots.txt
new file mode 100644
index 000000000..190c6ce04
--- /dev/null
+++ b/website/source/robots.txt
@@ -0,0 +1,8 @@
+---
+layout: false
+noindex: true
+---
+
+User-agent: *
+Disallow: /404
+Disallow: /500
diff --git a/website/source/sitemap.xml.builder b/website/source/sitemap.xml.builder
new file mode 100644
index 000000000..a08b5b0e3
--- /dev/null
+++ b/website/source/sitemap.xml.builder
@@ -0,0 +1,19 @@
+---
+layout: false
+---
+
+xml.instruct!
+xml.urlset 'xmlns' => "http://www.sitemaps.org/schemas/sitemap/0.9" do
+  sitemap
+    .resources
+    .select { |page| page.path =~ /\.html/ }
+    .select { |page| !page.data.noindex }
+    .each do |page|
+      xml.url do
+        xml.loc File.join(base_url, page.url)
+        xml.lastmod Date.today.to_time.iso8601
+        xml.changefreq page.data.changefreq || "monthly"
+        xml.priority page.data.priority || "0.5"
+      end
+  end
+end
diff --git a/website/source/stylesheets/_components.scss b/website/source/stylesheets/_components.scss
deleted file mode 100644
index 2f03d3c9a..000000000
--- a/website/source/stylesheets/_components.scss
+++ /dev/null
@@ -1,323 +0,0 @@
-header .header {
-    height: 200px;
-    background: #000000;
-
-    h1 {
-        margin-bottom: -8px;
-        margin-top: 60px;
-        text-transform: uppercase;
-    }
-
-    span {
-        font-size: 20px;
-    }
-}
-
-.hero {
-    height: $hero-height;
-    background: #000000 url(/images/hero_image.jpg) no-repeat 35px -40px;
-    background-size: 960px 467px;
-
-    h2 {
-        margin-top: 70px;
-    }
-}
-
-.belt {
-    &.download {
-        background-color: $white;
-        @extend .padded-sm;
-    }
-
-    .download-container {
-        background: url(/images/down_arrow.png) no-repeat top left;
-        display: inline-block;
-        min-height: 73px;
-        margin: 0 auto;
-        padding-left: 100px;
-    }
-
-    .download-row {
-        text-align: center;
-
-        .small {
-            text-align: left;
-        }
-    }
-
-    h2 {
-        font-family: $serif;
-        font-size: 44px;
-        color: #7bc6b1;
-        margin: 0px;
-        padding: 0px;
-        padding-top: 7px;
-        padding-bottom: 3px;
-        line-height: 1.0;
-        white-space: nowrap;
-
-        &:hover {
-            color: $dark-background;
-        }
-    }
-
-    span {
-        color: $gray-dark;
-    }
-}
-
-.downloads {
-    margin-top: 20px;
-
-    .description {
-        margin-bottom: 20px;
-    }
-
-    .download {
-        border-bottom: 1px solid #b2b2b2;
-        padding-bottom: 15px;
-        margin-bottom: 15px;
-
-        .details {
-            padding-left: 95px;
-
-            li {
-                display: inline-block;
-
-                &:after {
-                    content: " | ";
-                }
-
-                &:last-child:after {
-                    content: "";
-                }
-            }
-
-            a {
-                font-size: 22px;
-                color: darken($green, 15%);
-
-                &:hover {
-                    color: darken($green, 30%);
-                }
-
-                &:active {
-                    color: darken($green, 50%);
-                }
-            }
-        }
-
-        .icon {
-            img {
-                width: 75px;
-            }
-        }
-
-        .os-name {
-            font-size: 40px;
-            margin-bottom: -3px;
-        }
-    }
-
-    .poweredby {
-        margin-top: 20px;
-        margin-bottom: 20px;
-
-        img {
-            display: block;
-            margin: 0 auto;
-            width: 122px;
-        }
-    }
-}
-
-.marketting {
-    p {
-        padding-left: 10px;
-        padding-right: 10px;
-        text-align: justify;
-    }
-}
-
-.docs-wrapper {
-    clear: right;
-
-    .docs-body {
-        float: left;
-        width: 70%;
-        max-width: 760px;
-        display: block;
-        @extend .white-background;
-
-        .docs-content {
-            padding: $docs-top-margin 80px;
-            display: block;
-
-            code {
-                background-color: #000;
-                border: 0;
-                color: #b1d631;
-                font-size: 14px;
-            }
-
-            a {
-                color: darken($green, 15%);
-
-                &:hover {
-                    color: darken($green, 30%);
-                }
-
-                &:active {
-                    color: darken($green, 50%);
-                }
-            }
-
-            ul,
-            ol {
-                list-style-position: inside;
-                margin-top: $baseline;
-                margin-left: 20px;
-                margin-right: 20px;
-
-                li {
-                    font-family: $serif;
-                    font-size: 17px;
-                    line-height: (30/17) !important;
-                    margin-bottom: $baseline;
-                }
-            }
-
-            ul {
-                list-style-type: circle;
-            }
-
-            ol {
-                list-style-type: decimal;
-            }
-
-            div.alert {
-                font-family: $serif;
-                font-size: 17px;
-                line-height: 1.5;
-                letter-spacing: 1px;
-                margin-left: -80px;
-                margin-right: -80px;
-                padding-top: 15px;
-                padding-bottom: 15px;
-                padding-left: 80px;
-                padding-right: 80px;
-                border-radius: 0;
-            }
-
-            pre {
-                border: 0;
-                font-size: 14px;
-                margin-left: -80px;
-                margin-right: -80px;
-                padding-top: 40px;
-                padding-bottom: 40px;
-                padding-left: 80px;
-                padding-right: 80px;
-                border-radius: 0;
-            }
-        }
-
-        .docs-background {
-            @extend .white-background;
-            height: 100%;
-            width: 70%;
-            max-width: 760px;
-            position: fixed;
-            top: 0;
-            left: $sidebar-width;
-            z-index: -9999;
-        }
-
-        section {
-            margin-top: $docs-top-margin;
-        }
-
-        h1 {
-            font-size: 40px;
-            line-height: (25/20);
-            text-transform: uppercase;
-        }
-
-        h2 {
-            margin-top: $baseline * 2;
-            text-transform: capitalize;
-        }
-
-        h3 {
-            margin-top: $baseline;
-            text-transform: capitalize;
-            font-size: 26px;
-        }
-    }
-}
-
-.pagination {
-    $border: 1px solid $gray-mid;
-    height: $nav-height;
-    border-top: $border;
-    font-size: 20px;
-    margin: 0px;
-
-    h4 {
-        display: inline-block;
-        margin-top: ($baseline * 1.7);
-        margin-left: $baseline;
-
-        @include respond-to(mobile) {
-            margin-top: 10px;
-        }
-    }
-
-    span {
-
-        @include respond-to(mobile) {
-            display: block;
-        }
-    }
-
-    .previous-section,
-    .next-section {
-        height: $nav-height;
-        display: block;
-
-        &:hover {
-            background-color: transparentize($gray-light, .7);
-        }
-    }
-
-    .previous-section {
-        width: $nav-height;
-        border-right: $border;
-        float: left;
-        background: $white url(/images/arrow-left.png) no-repeat center center;
-        @include respond-to(mobile) {
-            width: 50%;
-            background-position: left center;
-        }
-    }
-
-    .next-section {
-        background: $white url(/images/arrow-right.png) no-repeat center right;
-    }
-}
-
-.people {
-    margin-top: 30px;
-
-    .person {
-        margin-bottom: 30px;
-
-        h3 {
-            text-transform: none;
-        }
-
-        .bio {
-            padding-left: 150px;
-        }
-    }
-}
diff --git a/website/source/stylesheets/_footer.scss b/website/source/stylesheets/_footer.scss
deleted file mode 100644
index 686a242e6..000000000
--- a/website/source/stylesheets/_footer.scss
+++ /dev/null
@@ -1,72 +0,0 @@
-footer {
-height: $nav-height;
-max-height: $nav-height;
-background-color: $black !important;
-padding: 0;
-margin: 0;
-text-transform: uppercase;
-color: $white;
-font-family: $sans;
-@include respond-to(mobile) {
-margin-right: -20px;
-margin-left: -20px;
-}
-
-	ul {
-	margin-top: 40px;
-	@include respond-to(mobile) {
-	margin-left: $baseline;
-	margin-top: $baseline;
-	}
-
-		li {
-		display: inline;
-		margin-right: 50px;
-		@include respond-to(mobile) {
-		margin-right: 20px;
-		display: list-item;
-		}
-		}
-
-		.hashi-logo {
-		background: url(/images/logo_footer.png) no-repeat center top;
-		height: 40px;
-		width: 40px;
-		background-size: 37px 40px;
-		text-indent: -999999px;
-		display: inline-block;
-		margin-top: -10px;
-		margin-right: 0;
-		@include respond-to(mobile) {
-		margin-top: -50px;
-		margin-right: $baseline;
-		}
-		}
-	}
-
-	.active {
-	color: $green;
-	}
-
-	button {
-	margin-top: 20px;
-	}
-
-
-}
-
-.page-wrap {
-min-height: 100%;
-/* equal to footer height */
-margin-bottom: -($nav-height);
-}
-
-.page-wrap:after {
-content: "";
-display: block;
-}
-
-.page-wrap:after {
-/* .push must be the same height as footer */
-height: $nav-height;
-}
diff --git a/website/source/stylesheets/_nav.scss b/website/source/stylesheets/_nav.scss
deleted file mode 100644
index 279b7155b..000000000
--- a/website/source/stylesheets/_nav.scss
+++ /dev/null
@@ -1,42 +0,0 @@
-nav {
-    height: $nav-height;
-    padding: $baseline 0;
-    padding: 0;
-    margin: 0;
-    min-width: 940px;
-    text-transform: uppercase;
-    color: $white;
-    font-family: $sans;
-    font-size: 16px;
-    border-bottom: 1px solid $border-dark;
-
-    ul {
-        margin-top: ($baseline * 2);
-        margin-left: $nav-height;
-
-        li {
-            display: inline-block;
-            margin-right: 50px;
-        }
-
-    }
-
-    .packer-logo {
-        background: url(/images/logo_nav.png) no-repeat center top;
-        height: 80px;
-        width: 80px;
-        background-size: 34px 50px;
-        text-indent: -999999px;
-        display: inline-block;
-        margin-top: 25px;
-    }
-
-    .active {
-        color: $green;
-    }
-
-    button {
-        margin-top: $baseline;
-    }
-
-} //nav
diff --git a/website/source/stylesheets/_reset.scss b/website/source/stylesheets/_reset.scss
deleted file mode 100644
index d4f7f0383..000000000
--- a/website/source/stylesheets/_reset.scss
+++ /dev/null
@@ -1,27 +0,0 @@
-form,
-input,
-textarea,
-button {
-padding: 0;
-margin: 0;
-vertical-align: middle;
-border: 0;
-box-shadow: none;
--moz-border-radius: 0;
--webkit-border-radius: 0;
--khtml-border-radius: 0;
-border-radius: 0;
-background-color: transparent;
-font-family: $mono;
-font-size: $base-font-size;
-line-height: 1.0;
-color: inherit;
-
-	&:focus {
-	line-height: 1.0;
-	box-shadow: none !important;
-	outline: none;
-	vertical-align: middle;
-
-	}
-}
\ No newline at end of file
diff --git a/website/source/stylesheets/_sidebar.scss b/website/source/stylesheets/_sidebar.scss
deleted file mode 100644
index ea822aa3b..000000000
--- a/website/source/stylesheets/_sidebar.scss
+++ /dev/null
@@ -1,49 +0,0 @@
-.sidebar {
-    $border: 1px solid $gray-dark;
-    font-size: 16px;
-    font-family: $mono;
-    color: $gray-light;
-    width: $sidebar-width;
-    float: left;
-    background-color: $sidebar-background-color;
-    height: 100%;
-
-    h2 {
-        color: $green;
-        text-transform: uppercase;
-        padding: $docs-top-margin 20px 0;
-    }
-
-    h4 {
-        color: $white;
-        text-transform: uppercase;
-        margin-bottom: -10px;
-    }
-
-    ul {
-        @extend .padded-sm;
-
-        li {
-            border-bottom: $border;
-            padding: 15px 0;
-            text-align: left;
-        }
-
-        li > * {
-            padding: auto 20px;
-            margin-left: 20px;
-            display: block;
-            width: 100%;
-        }
-    }
-
-    .sidebar-background {
-        background-color: $sidebar-background-color;
-        height: 100%;
-        width: $sidebar-width;
-        position: fixed;
-        top: 0;
-        left: 0;
-        z-index: -9999;
-    }
-}
diff --git a/website/source/stylesheets/_styles.scss b/website/source/stylesheets/_styles.scss
deleted file mode 100644
index 777e00495..000000000
--- a/website/source/stylesheets/_styles.scss
+++ /dev/null
@@ -1,241 +0,0 @@
-* {
-    margin: 0;
-}
-
-html,
-body {
-    margin: 0;
-    height: 100%;
-}
-
-html {
-    -webkit-tap-highlight-color: transparent;
-    -webkit-font-smoothing: antialiased;
-}
-
-body {
-    background-color: $background;
-    font-family: $sans;
-    letter-spacing: 1px;
-    font-size: $base-font-size;
-    line-height: $base-line-height;
-}
-
-h1,
-h2,
-h3,
-h4,
-h5,
-h6 {
-    letter-spacing: 2px;
-    font-weight: normal;
-}
-
-h1 {
-    font-family: $sans;
-    font-size: 70px;
-    line-height: (80/70);
-    @include respond-to(mobile) {
-        font-size: 50px;
-        line-height: (50/45);
-    }
-}
-
-h2 {
-    font-family: $sans;
-    font-size: 40px;
-    line-height: (50/40);
-
-    &.has-dividers {
-        //overflow: auto !important;
-        display: table-cell;
-        text-align: center;
-        vertical-align: middle;
-        @include respond-to(mobile) {
-            display: block;
-        }
-    }
-}
-
-h3 {
-    font-family: $sans;
-    font-size: 20px;
-    line-height: (30/20);
-}
-
-h4 {
-    font-family: $mono;
-    font-size: 20px;
-    line-height: (30/20);
-}
-
-h5 {
-    font-family: $sans;
-    font-size: 16px;
-    line-height: (22/16);
-}
-
-h6 {
-    font-family: $mono;
-    font-size: 16px;
-    line-height: (22/16);
-}
-
-p {
-    font-family: $serif;
-    font-size: 17px;
-    line-height: (30/17);
-    letter-spacing: 1px;
-
-    &.large-text {
-        font-size: 20px;
-        line-height: (35/20);
-    }
-
-    a {
-        color: $green;
-        &:hover {
-            color: darken($green, 30%);
-        }
-        &:active {
-            color: darken($green, 50%);
-        }
-    }
-}
-
-a {
-    color: inherit;
-    text-decoration: none;
-
-    &:hover {
-        color: inherit;
-        text-decoration: none;
-    }
-
-    &:visited {
-
-    }
-
-    &:active {
-
-    }
-
-}
-
-dt {
-    font-size: 18px;
-}
-
-dd {
-    font-family: $serif;
-    font-size: 17px;
-    line-height: 1.5;
-    letter-spacing: 1px;
-    margin-bottom: 30px;
-}
-
-ul,
-ol {
-    margin: 0;
-    padding: 0;
-    list-style-type: none;
-}
-
-em {
-    font-style: italic;
-}
-
-strong {
-    font-weight: bold;
-}
-
-small,
-.small {
-    font-size: 13px;
-}
-
-hr {
-    margin: ($baseline * 2) 0;
-    border-color: $gray-mid;
-    border-bottom: 0;
-}
-
-pre {
-    background-color: $black;
-    color: $white;
-    margin: $baseline 0;
-}
-
-table {
-    font-family: $mono;
-    margin: ($baseline * 2) 0;
-    color: $gray-dark;
-
-    th {
-        color: $black;
-        font-weight: normal !important;
-    }
-}
-
-::selection {
-    background: #ffff00; /* Safari */
-    color: $black;
-}
-::-moz-selection {
-    background: #ffff00; /* Firefox */
-    color: $black;
-}
-
-input {
-
-}
-
-button {
-    height: $button-height;
-    background-color: transparent;
-    border-width: 2px;
-    border-style: solid;
-    padding: 0 30px;
-    text-transform: uppercase;
-    letter-spacing: 3px;
-    @include rounded(5px);
-
-    &.spaced {
-        margin-right: 20px;
-    }
-
-    &.primary {
-        color: $green;
-        border-color: $green;
-
-        &:hover {
-            background-color: transparentize($green, .7);
-        }
-
-        &:active {
-            background-color: transparentize($green, .5);
-        }
-    }
-
-    &.secondary {
-        color: $black;
-        border-color: $black;
-
-        &:hover {
-            background-color: transparentize($black, .9);
-        }
-
-        &:active {
-            background-color: transparentize($black, .7);
-        }
-    }
-
-    &.inline {
-        margin: auto $baseline;
-        @include respond-to(mobile) {
-            display: block;
-            width: 100%;
-            margin: $baseline 0;
-        }
-    }
-}
diff --git a/website/source/stylesheets/bootstrap.min.css b/website/source/stylesheets/bootstrap.min.css
deleted file mode 100644
index b6428e695..000000000
--- a/website/source/stylesheets/bootstrap.min.css
+++ /dev/null
@@ -1,9 +0,0 @@
-/*!
- * Bootstrap v2.3.2
- *
- * Copyright 2012 Twitter, Inc
- * Licensed under the Apache License v2.0
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Designed and built with all the love in the world @twitter by @mdo and @fat.
- */.clearfix{*zoom:1}.clearfix:before,.clearfix:after{display:table;line-height:0;content:""}.clearfix:after{clear:both}.hide-text{font:0/0 a;color:transparent;text-shadow:none;background-color:transparent;border:0}.input-block-level{display:block;width:100%;min-height:30px;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}article,aside,details,figcaption,figure,footer,header,hgroup,nav,section{display:block}audio,canvas,video{display:inline-block;*display:inline;*zoom:1}audio:not([controls]){display:none}html{font-size:100%;-webkit-text-size-adjust:100%;-ms-text-size-adjust:100%}a:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}a:hover,a:active{outline:0}sub,sup{position:relative;font-size:75%;line-height:0;vertical-align:baseline}sup{top:-0.5em}sub{bottom:-0.25em}img{width:auto\9;height:auto;max-width:100%;vertical-align:middle;border:0;-ms-interpolation-mode:bicubic}#map_canvas img,.google-maps img{max-width:none}button,input,select,textarea{margin:0;font-size:100%;vertical-align:middle}button,input{*overflow:visible;line-height:normal}button::-moz-focus-inner,input::-moz-focus-inner{padding:0;border:0}button,html input[type="button"],input[type="reset"],input[type="submit"]{cursor:pointer;-webkit-appearance:button}label,select,button,input[type="button"],input[type="reset"],input[type="submit"],input[type="radio"],input[type="checkbox"]{cursor:pointer}input[type="search"]{-webkit-box-sizing:content-box;-moz-box-sizing:content-box;box-sizing:content-box;-webkit-appearance:textfield}input[type="search"]::-webkit-search-decoration,input[type="search"]::-webkit-search-cancel-button{-webkit-appearance:none}textarea{overflow:auto;vertical-align:top}@media print{*{color:#000!important;text-shadow:none!important;background:transparent!important;box-shadow:none!important}a,a:visited{text-decoration:underline}a[href]:after{content:" (" attr(href) ")"}abbr[title]:after{content:" (" attr(title) ")"}.ir a:after,a[href^="javascript:"]:after,a[href^="#"]:after{content:""}pre,blockquote{border:1px solid #999;page-break-inside:avoid}thead{display:table-header-group}tr,img{page-break-inside:avoid}img{max-width:100%!important}@page{margin:.5cm}p,h2,h3{orphans:3;widows:3}h2,h3{page-break-after:avoid}}body{margin:0;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:14px;line-height:20px;color:#333;background-color:#fff}a{color:#08c;text-decoration:none}a:hover,a:focus{color:#005580;text-decoration:underline}.img-rounded{-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.img-polaroid{padding:4px;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.2);-webkit-box-shadow:0 1px 3px rgba(0,0,0,0.1);-moz-box-shadow:0 1px 3px rgba(0,0,0,0.1);box-shadow:0 1px 3px rgba(0,0,0,0.1)}.img-circle{-webkit-border-radius:500px;-moz-border-radius:500px;border-radius:500px}.row{margin-left:-20px;*zoom:1}.row:before,.row:after{display:table;line-height:0;content:""}.row:after{clear:both}[class*="span"]{float:left;min-height:1px;margin-left:20px}.container,.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:940px}.span12{width:940px}.span11{width:860px}.span10{width:780px}.span9{width:700px}.span8{width:620px}.span7{width:540px}.span6{width:460px}.span5{width:380px}.span4{width:300px}.span3{width:220px}.span2{width:140px}.span1{width:60px}.offset12{margin-left:980px}.offset11{margin-left:900px}.offset10{margin-left:820px}.offset9{margin-left:740px}.offset8{margin-left:660px}.offset7{margin-left:580px}.offset6{margin-left:500px}.offset5{margin-left:420px}.offset4{margin-left:340px}.offset3{margin-left:260px}.offset2{margin-left:180px}.offset1{margin-left:100px}.row-fluid{width:100%;*zoom:1}.row-fluid:before,.row-fluid:after{display:table;line-height:0;content:""}.row-fluid:after{clear:both}.row-fluid [class*="span"]{display:block;float:left;width:100%;min-height:30px;margin-left:2.127659574468085%;*margin-left:2.074468085106383%;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.row-fluid [class*="span"]:first-child{margin-left:0}.row-fluid .controls-row [class*="span"]+[class*="span"]{margin-left:2.127659574468085%}.row-fluid .span12{width:100%;*width:99.94680851063829%}.row-fluid .span11{width:91.48936170212765%;*width:91.43617021276594%}.row-fluid .span10{width:82.97872340425532%;*width:82.92553191489361%}.row-fluid .span9{width:74.46808510638297%;*width:74.41489361702126%}.row-fluid .span8{width:65.95744680851064%;*width:65.90425531914893%}.row-fluid .span7{width:57.44680851063829%;*width:57.39361702127659%}.row-fluid .span6{width:48.93617021276595%;*width:48.88297872340425%}.row-fluid .span5{width:40.42553191489362%;*width:40.37234042553192%}.row-fluid .span4{width:31.914893617021278%;*width:31.861702127659576%}.row-fluid .span3{width:23.404255319148934%;*width:23.351063829787233%}.row-fluid .span2{width:14.893617021276595%;*width:14.840425531914894%}.row-fluid .span1{width:6.382978723404255%;*width:6.329787234042553%}.row-fluid .offset12{margin-left:104.25531914893617%;*margin-left:104.14893617021275%}.row-fluid .offset12:first-child{margin-left:102.12765957446808%;*margin-left:102.02127659574467%}.row-fluid .offset11{margin-left:95.74468085106382%;*margin-left:95.6382978723404%}.row-fluid .offset11:first-child{margin-left:93.61702127659574%;*margin-left:93.51063829787232%}.row-fluid .offset10{margin-left:87.23404255319149%;*margin-left:87.12765957446807%}.row-fluid .offset10:first-child{margin-left:85.1063829787234%;*margin-left:84.99999999999999%}.row-fluid .offset9{margin-left:78.72340425531914%;*margin-left:78.61702127659572%}.row-fluid .offset9:first-child{margin-left:76.59574468085106%;*margin-left:76.48936170212764%}.row-fluid .offset8{margin-left:70.2127659574468%;*margin-left:70.10638297872339%}.row-fluid .offset8:first-child{margin-left:68.08510638297872%;*margin-left:67.9787234042553%}.row-fluid .offset7{margin-left:61.70212765957446%;*margin-left:61.59574468085106%}.row-fluid .offset7:first-child{margin-left:59.574468085106375%;*margin-left:59.46808510638297%}.row-fluid .offset6{margin-left:53.191489361702125%;*margin-left:53.085106382978715%}.row-fluid .offset6:first-child{margin-left:51.063829787234035%;*margin-left:50.95744680851063%}.row-fluid .offset5{margin-left:44.68085106382979%;*margin-left:44.57446808510638%}.row-fluid .offset5:first-child{margin-left:42.5531914893617%;*margin-left:42.4468085106383%}.row-fluid .offset4{margin-left:36.170212765957444%;*margin-left:36.06382978723405%}.row-fluid .offset4:first-child{margin-left:34.04255319148936%;*margin-left:33.93617021276596%}.row-fluid .offset3{margin-left:27.659574468085104%;*margin-left:27.5531914893617%}.row-fluid .offset3:first-child{margin-left:25.53191489361702%;*margin-left:25.425531914893618%}.row-fluid .offset2{margin-left:19.148936170212764%;*margin-left:19.04255319148936%}.row-fluid .offset2:first-child{margin-left:17.02127659574468%;*margin-left:16.914893617021278%}.row-fluid .offset1{margin-left:10.638297872340425%;*margin-left:10.53191489361702%}.row-fluid .offset1:first-child{margin-left:8.51063829787234%;*margin-left:8.404255319148938%}[class*="span"].hide,.row-fluid [class*="span"].hide{display:none}[class*="span"].pull-right,.row-fluid [class*="span"].pull-right{float:right}.container{margin-right:auto;margin-left:auto;*zoom:1}.container:before,.container:after{display:table;line-height:0;content:""}.container:after{clear:both}.container-fluid{padding-right:20px;padding-left:20px;*zoom:1}.container-fluid:before,.container-fluid:after{display:table;line-height:0;content:""}.container-fluid:after{clear:both}p{margin:0 0 10px}.lead{margin-bottom:20px;font-size:21px;font-weight:200;line-height:30px}small{font-size:85%}strong{font-weight:bold}em{font-style:italic}cite{font-style:normal}.muted{color:#999}a.muted:hover,a.muted:focus{color:#808080}.text-warning{color:#c09853}a.text-warning:hover,a.text-warning:focus{color:#a47e3c}.text-error{color:#b94a48}a.text-error:hover,a.text-error:focus{color:#953b39}.text-info{color:#3a87ad}a.text-info:hover,a.text-info:focus{color:#2d6987}.text-success{color:#468847}a.text-success:hover,a.text-success:focus{color:#356635}.text-left{text-align:left}.text-right{text-align:right}.text-center{text-align:center}h1,h2,h3,h4,h5,h6{margin:10px 0;font-family:inherit;font-weight:bold;line-height:20px;color:inherit;text-rendering:optimizelegibility}h1 small,h2 small,h3 small,h4 small,h5 small,h6 small{font-weight:normal;line-height:1;color:#999}h1,h2,h3{line-height:40px}h1{font-size:38.5px}h2{font-size:31.5px}h3{font-size:24.5px}h4{font-size:17.5px}h5{font-size:14px}h6{font-size:11.9px}h1 small{font-size:24.5px}h2 small{font-size:17.5px}h3 small{font-size:14px}h4 small{font-size:14px}.page-header{padding-bottom:9px;margin:20px 0 30px;border-bottom:1px solid #eee}ul,ol{padding:0;margin:0 0 10px 25px}ul ul,ul ol,ol ol,ol ul{margin-bottom:0}li{line-height:20px}ul.unstyled,ol.unstyled{margin-left:0;list-style:none}ul.inline,ol.inline{margin-left:0;list-style:none}ul.inline>li,ol.inline>li{display:inline-block;*display:inline;padding-right:5px;padding-left:5px;*zoom:1}dl{margin-bottom:20px}dt,dd{line-height:20px}dt{font-weight:bold}dd{margin-left:10px}.dl-horizontal{*zoom:1}.dl-horizontal:before,.dl-horizontal:after{display:table;line-height:0;content:""}.dl-horizontal:after{clear:both}.dl-horizontal dt{float:left;width:160px;overflow:hidden;clear:left;text-align:right;text-overflow:ellipsis;white-space:nowrap}.dl-horizontal dd{margin-left:180px}hr{margin:20px 0;border:0;border-top:1px solid #eee;border-bottom:1px solid #fff}abbr[title],abbr[data-original-title]{cursor:help;border-bottom:1px dotted #999}abbr.initialism{font-size:90%;text-transform:uppercase}blockquote{padding:0 0 0 15px;margin:0 0 20px;border-left:5px solid #eee}blockquote p{margin-bottom:0;font-size:17.5px;font-weight:300;line-height:1.25}blockquote small{display:block;line-height:20px;color:#999}blockquote small:before{content:'\2014 \00A0'}blockquote.pull-right{float:right;padding-right:15px;padding-left:0;border-right:5px solid #eee;border-left:0}blockquote.pull-right p,blockquote.pull-right small{text-align:right}blockquote.pull-right small:before{content:''}blockquote.pull-right small:after{content:'\00A0 \2014'}q:before,q:after,blockquote:before,blockquote:after{content:""}address{display:block;margin-bottom:20px;font-style:normal;line-height:20px}code,pre{padding:0 3px 2px;font-family:Monaco,Menlo,Consolas,"Courier New",monospace;font-size:12px;color:#333;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}code{padding:2px 4px;color:#d14;white-space:nowrap;background-color:#f7f7f9;border:1px solid #e1e1e8}pre{display:block;padding:9.5px;margin:0 0 10px;font-size:13px;line-height:20px;word-break:break-all;word-wrap:break-word;white-space:pre;white-space:pre-wrap;background-color:#f5f5f5;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.15);-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}pre.prettyprint{margin-bottom:20px}pre code{padding:0;color:inherit;white-space:pre;white-space:pre-wrap;background-color:transparent;border:0}.pre-scrollable{max-height:340px;overflow-y:scroll}form{margin:0 0 20px}fieldset{padding:0;margin:0;border:0}legend{display:block;width:100%;padding:0;margin-bottom:20px;font-size:21px;line-height:40px;color:#333;border:0;border-bottom:1px solid #e5e5e5}legend small{font-size:15px;color:#999}label,input,button,select,textarea{font-size:14px;font-weight:normal;line-height:20px}input,button,select,textarea{font-family:"Helvetica Neue",Helvetica,Arial,sans-serif}label{display:block;margin-bottom:5px}select,textarea,input[type="text"],input[type="password"],input[type="datetime"],input[type="datetime-local"],input[type="date"],input[type="month"],input[type="time"],input[type="week"],input[type="number"],input[type="email"],input[type="url"],input[type="search"],input[type="tel"],input[type="color"],.uneditable-input{display:inline-block;height:20px;padding:4px 6px;margin-bottom:10px;font-size:14px;line-height:20px;color:#555;vertical-align:middle;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}input,textarea,.uneditable-input{width:206px}textarea{height:auto}textarea,input[type="text"],input[type="password"],input[type="datetime"],input[type="datetime-local"],input[type="date"],input[type="month"],input[type="time"],input[type="week"],input[type="number"],input[type="email"],input[type="url"],input[type="search"],input[type="tel"],input[type="color"],.uneditable-input{background-color:#fff;border:1px solid #ccc;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-webkit-transition:border linear .2s,box-shadow linear .2s;-moz-transition:border linear .2s,box-shadow linear .2s;-o-transition:border linear .2s,box-shadow linear .2s;transition:border linear .2s,box-shadow linear .2s}textarea:focus,input[type="text"]:focus,input[type="password"]:focus,input[type="datetime"]:focus,input[type="datetime-local"]:focus,input[type="date"]:focus,input[type="month"]:focus,input[type="time"]:focus,input[type="week"]:focus,input[type="number"]:focus,input[type="email"]:focus,input[type="url"]:focus,input[type="search"]:focus,input[type="tel"]:focus,input[type="color"]:focus,.uneditable-input:focus{border-color:rgba(82,168,236,0.8);outline:0;outline:thin dotted \9;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(82,168,236,0.6);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(82,168,236,0.6);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 8px rgba(82,168,236,0.6)}input[type="radio"],input[type="checkbox"]{margin:4px 0 0;margin-top:1px \9;*margin-top:0;line-height:normal}input[type="file"],input[type="image"],input[type="submit"],input[type="reset"],input[type="button"],input[type="radio"],input[type="checkbox"]{width:auto}select,input[type="file"]{height:30px;*margin-top:4px;line-height:30px}select{width:220px;background-color:#fff;border:1px solid #ccc}select[multiple],select[size]{height:auto}select:focus,input[type="file"]:focus,input[type="radio"]:focus,input[type="checkbox"]:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.uneditable-input,.uneditable-textarea{color:#999;cursor:not-allowed;background-color:#fcfcfc;border-color:#ccc;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.025);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,0.025);box-shadow:inset 0 1px 2px rgba(0,0,0,0.025)}.uneditable-input{overflow:hidden;white-space:nowrap}.uneditable-textarea{width:auto;height:auto}input:-moz-placeholder,textarea:-moz-placeholder{color:#999}input:-ms-input-placeholder,textarea:-ms-input-placeholder{color:#999}input::-webkit-input-placeholder,textarea::-webkit-input-placeholder{color:#999}.radio,.checkbox{min-height:20px;padding-left:20px}.radio input[type="radio"],.checkbox input[type="checkbox"]{float:left;margin-left:-20px}.controls>.radio:first-child,.controls>.checkbox:first-child{padding-top:5px}.radio.inline,.checkbox.inline{display:inline-block;padding-top:5px;margin-bottom:0;vertical-align:middle}.radio.inline+.radio.inline,.checkbox.inline+.checkbox.inline{margin-left:10px}.input-mini{width:60px}.input-small{width:90px}.input-medium{width:150px}.input-large{width:210px}.input-xlarge{width:270px}.input-xxlarge{width:530px}input[class*="span"],select[class*="span"],textarea[class*="span"],.uneditable-input[class*="span"],.row-fluid input[class*="span"],.row-fluid select[class*="span"],.row-fluid textarea[class*="span"],.row-fluid .uneditable-input[class*="span"]{float:none;margin-left:0}.input-append input[class*="span"],.input-append .uneditable-input[class*="span"],.input-prepend input[class*="span"],.input-prepend .uneditable-input[class*="span"],.row-fluid input[class*="span"],.row-fluid select[class*="span"],.row-fluid textarea[class*="span"],.row-fluid .uneditable-input[class*="span"],.row-fluid .input-prepend [class*="span"],.row-fluid .input-append [class*="span"]{display:inline-block}input,textarea,.uneditable-input{margin-left:0}.controls-row [class*="span"]+[class*="span"]{margin-left:20px}input.span12,textarea.span12,.uneditable-input.span12{width:926px}input.span11,textarea.span11,.uneditable-input.span11{width:846px}input.span10,textarea.span10,.uneditable-input.span10{width:766px}input.span9,textarea.span9,.uneditable-input.span9{width:686px}input.span8,textarea.span8,.uneditable-input.span8{width:606px}input.span7,textarea.span7,.uneditable-input.span7{width:526px}input.span6,textarea.span6,.uneditable-input.span6{width:446px}input.span5,textarea.span5,.uneditable-input.span5{width:366px}input.span4,textarea.span4,.uneditable-input.span4{width:286px}input.span3,textarea.span3,.uneditable-input.span3{width:206px}input.span2,textarea.span2,.uneditable-input.span2{width:126px}input.span1,textarea.span1,.uneditable-input.span1{width:46px}.controls-row{*zoom:1}.controls-row:before,.controls-row:after{display:table;line-height:0;content:""}.controls-row:after{clear:both}.controls-row [class*="span"],.row-fluid .controls-row [class*="span"]{float:left}.controls-row .checkbox[class*="span"],.controls-row .radio[class*="span"]{padding-top:5px}input[disabled],select[disabled],textarea[disabled],input[readonly],select[readonly],textarea[readonly]{cursor:not-allowed;background-color:#eee}input[type="radio"][disabled],input[type="checkbox"][disabled],input[type="radio"][readonly],input[type="checkbox"][readonly]{background-color:transparent}.control-group.warning .control-label,.control-group.warning .help-block,.control-group.warning .help-inline{color:#c09853}.control-group.warning .checkbox,.control-group.warning .radio,.control-group.warning input,.control-group.warning select,.control-group.warning textarea{color:#c09853}.control-group.warning input,.control-group.warning select,.control-group.warning textarea{border-color:#c09853;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.warning input:focus,.control-group.warning select:focus,.control-group.warning textarea:focus{border-color:#a47e3c;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #dbc59e;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #dbc59e;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #dbc59e}.control-group.warning .input-prepend .add-on,.control-group.warning .input-append .add-on{color:#c09853;background-color:#fcf8e3;border-color:#c09853}.control-group.error .control-label,.control-group.error .help-block,.control-group.error .help-inline{color:#b94a48}.control-group.error .checkbox,.control-group.error .radio,.control-group.error input,.control-group.error select,.control-group.error textarea{color:#b94a48}.control-group.error input,.control-group.error select,.control-group.error textarea{border-color:#b94a48;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.error input:focus,.control-group.error select:focus,.control-group.error textarea:focus{border-color:#953b39;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #d59392;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #d59392;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #d59392}.control-group.error .input-prepend .add-on,.control-group.error .input-append .add-on{color:#b94a48;background-color:#f2dede;border-color:#b94a48}.control-group.success .control-label,.control-group.success .help-block,.control-group.success .help-inline{color:#468847}.control-group.success .checkbox,.control-group.success .radio,.control-group.success input,.control-group.success select,.control-group.success textarea{color:#468847}.control-group.success input,.control-group.success select,.control-group.success textarea{border-color:#468847;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.success input:focus,.control-group.success select:focus,.control-group.success textarea:focus{border-color:#356635;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7aba7b;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7aba7b;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7aba7b}.control-group.success .input-prepend .add-on,.control-group.success .input-append .add-on{color:#468847;background-color:#dff0d8;border-color:#468847}.control-group.info .control-label,.control-group.info .help-block,.control-group.info .help-inline{color:#3a87ad}.control-group.info .checkbox,.control-group.info .radio,.control-group.info input,.control-group.info select,.control-group.info textarea{color:#3a87ad}.control-group.info input,.control-group.info select,.control-group.info textarea{border-color:#3a87ad;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075);box-shadow:inset 0 1px 1px rgba(0,0,0,0.075)}.control-group.info input:focus,.control-group.info select:focus,.control-group.info textarea:focus{border-color:#2d6987;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7ab5d3;-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7ab5d3;box-shadow:inset 0 1px 1px rgba(0,0,0,0.075),0 0 6px #7ab5d3}.control-group.info .input-prepend .add-on,.control-group.info .input-append .add-on{color:#3a87ad;background-color:#d9edf7;border-color:#3a87ad}input:focus:invalid,textarea:focus:invalid,select:focus:invalid{color:#b94a48;border-color:#ee5f5b}input:focus:invalid:focus,textarea:focus:invalid:focus,select:focus:invalid:focus{border-color:#e9322d;-webkit-box-shadow:0 0 6px #f8b9b7;-moz-box-shadow:0 0 6px #f8b9b7;box-shadow:0 0 6px #f8b9b7}.form-actions{padding:19px 20px 20px;margin-top:20px;margin-bottom:20px;background-color:#f5f5f5;border-top:1px solid #e5e5e5;*zoom:1}.form-actions:before,.form-actions:after{display:table;line-height:0;content:""}.form-actions:after{clear:both}.help-block,.help-inline{color:#595959}.help-block{display:block;margin-bottom:10px}.help-inline{display:inline-block;*display:inline;padding-left:5px;vertical-align:middle;*zoom:1}.input-append,.input-prepend{display:inline-block;margin-bottom:10px;font-size:0;white-space:nowrap;vertical-align:middle}.input-append input,.input-prepend input,.input-append select,.input-prepend select,.input-append .uneditable-input,.input-prepend .uneditable-input,.input-append .dropdown-menu,.input-prepend .dropdown-menu,.input-append .popover,.input-prepend .popover{font-size:14px}.input-append input,.input-prepend input,.input-append select,.input-prepend select,.input-append .uneditable-input,.input-prepend .uneditable-input{position:relative;margin-bottom:0;*margin-left:0;vertical-align:top;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.input-append input:focus,.input-prepend input:focus,.input-append select:focus,.input-prepend select:focus,.input-append .uneditable-input:focus,.input-prepend .uneditable-input:focus{z-index:2}.input-append .add-on,.input-prepend .add-on{display:inline-block;width:auto;height:20px;min-width:16px;padding:4px 5px;font-size:14px;font-weight:normal;line-height:20px;text-align:center;text-shadow:0 1px 0 #fff;background-color:#eee;border:1px solid #ccc}.input-append .add-on,.input-prepend .add-on,.input-append .btn,.input-prepend .btn,.input-append .btn-group>.dropdown-toggle,.input-prepend .btn-group>.dropdown-toggle{vertical-align:top;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.input-append .active,.input-prepend .active{background-color:#a9dba9;border-color:#46a546}.input-prepend .add-on,.input-prepend .btn{margin-right:-1px}.input-prepend .add-on:first-child,.input-prepend .btn:first-child{-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.input-append input,.input-append select,.input-append .uneditable-input{-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.input-append input+.btn-group .btn:last-child,.input-append select+.btn-group .btn:last-child,.input-append .uneditable-input+.btn-group .btn:last-child{-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.input-append .add-on,.input-append .btn,.input-append .btn-group{margin-left:-1px}.input-append .add-on:last-child,.input-append .btn:last-child,.input-append .btn-group:last-child>.dropdown-toggle{-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.input-prepend.input-append input,.input-prepend.input-append select,.input-prepend.input-append .uneditable-input{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.input-prepend.input-append input+.btn-group .btn,.input-prepend.input-append select+.btn-group .btn,.input-prepend.input-append .uneditable-input+.btn-group .btn{-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.input-prepend.input-append .add-on:first-child,.input-prepend.input-append .btn:first-child{margin-right:-1px;-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.input-prepend.input-append .add-on:last-child,.input-prepend.input-append .btn:last-child{margin-left:-1px;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.input-prepend.input-append .btn-group:first-child{margin-left:0}input.search-query{padding-right:14px;padding-right:4px \9;padding-left:14px;padding-left:4px \9;margin-bottom:0;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.form-search .input-append .search-query,.form-search .input-prepend .search-query{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.form-search .input-append .search-query{-webkit-border-radius:14px 0 0 14px;-moz-border-radius:14px 0 0 14px;border-radius:14px 0 0 14px}.form-search .input-append .btn{-webkit-border-radius:0 14px 14px 0;-moz-border-radius:0 14px 14px 0;border-radius:0 14px 14px 0}.form-search .input-prepend .search-query{-webkit-border-radius:0 14px 14px 0;-moz-border-radius:0 14px 14px 0;border-radius:0 14px 14px 0}.form-search .input-prepend .btn{-webkit-border-radius:14px 0 0 14px;-moz-border-radius:14px 0 0 14px;border-radius:14px 0 0 14px}.form-search input,.form-inline input,.form-horizontal input,.form-search textarea,.form-inline textarea,.form-horizontal textarea,.form-search select,.form-inline select,.form-horizontal select,.form-search .help-inline,.form-inline .help-inline,.form-horizontal .help-inline,.form-search .uneditable-input,.form-inline .uneditable-input,.form-horizontal .uneditable-input,.form-search .input-prepend,.form-inline .input-prepend,.form-horizontal .input-prepend,.form-search .input-append,.form-inline .input-append,.form-horizontal .input-append{display:inline-block;*display:inline;margin-bottom:0;vertical-align:middle;*zoom:1}.form-search .hide,.form-inline .hide,.form-horizontal .hide{display:none}.form-search label,.form-inline label,.form-search .btn-group,.form-inline .btn-group{display:inline-block}.form-search .input-append,.form-inline .input-append,.form-search .input-prepend,.form-inline .input-prepend{margin-bottom:0}.form-search .radio,.form-search .checkbox,.form-inline .radio,.form-inline .checkbox{padding-left:0;margin-bottom:0;vertical-align:middle}.form-search .radio input[type="radio"],.form-search .checkbox input[type="checkbox"],.form-inline .radio input[type="radio"],.form-inline .checkbox input[type="checkbox"]{float:left;margin-right:3px;margin-left:0}.control-group{margin-bottom:10px}legend+.control-group{margin-top:20px;-webkit-margin-top-collapse:separate}.form-horizontal .control-group{margin-bottom:20px;*zoom:1}.form-horizontal .control-group:before,.form-horizontal .control-group:after{display:table;line-height:0;content:""}.form-horizontal .control-group:after{clear:both}.form-horizontal .control-label{float:left;width:160px;padding-top:5px;text-align:right}.form-horizontal .controls{*display:inline-block;*padding-left:20px;margin-left:180px;*margin-left:0}.form-horizontal .controls:first-child{*padding-left:180px}.form-horizontal .help-block{margin-bottom:0}.form-horizontal input+.help-block,.form-horizontal select+.help-block,.form-horizontal textarea+.help-block,.form-horizontal .uneditable-input+.help-block,.form-horizontal .input-prepend+.help-block,.form-horizontal .input-append+.help-block{margin-top:10px}.form-horizontal .form-actions{padding-left:180px}table{max-width:100%;background-color:transparent;border-collapse:collapse;border-spacing:0}.table{width:100%;margin-bottom:20px}.table th,.table td{padding:8px;line-height:20px;text-align:left;vertical-align:top;border-top:1px solid #ddd}.table th{font-weight:bold}.table thead th{vertical-align:bottom}.table caption+thead tr:first-child th,.table caption+thead tr:first-child td,.table colgroup+thead tr:first-child th,.table colgroup+thead tr:first-child td,.table thead:first-child tr:first-child th,.table thead:first-child tr:first-child td{border-top:0}.table tbody+tbody{border-top:2px solid #ddd}.table .table{background-color:#fff}.table-condensed th,.table-condensed td{padding:4px 5px}.table-bordered{border:1px solid #ddd;border-collapse:separate;*border-collapse:collapse;border-left:0;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.table-bordered th,.table-bordered td{border-left:1px solid #ddd}.table-bordered caption+thead tr:first-child th,.table-bordered caption+tbody tr:first-child th,.table-bordered caption+tbody tr:first-child td,.table-bordered colgroup+thead tr:first-child th,.table-bordered colgroup+tbody tr:first-child th,.table-bordered colgroup+tbody tr:first-child td,.table-bordered thead:first-child tr:first-child th,.table-bordered tbody:first-child tr:first-child th,.table-bordered tbody:first-child tr:first-child td{border-top:0}.table-bordered thead:first-child tr:first-child>th:first-child,.table-bordered tbody:first-child tr:first-child>td:first-child,.table-bordered tbody:first-child tr:first-child>th:first-child{-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-topleft:4px}.table-bordered thead:first-child tr:first-child>th:last-child,.table-bordered tbody:first-child tr:first-child>td:last-child,.table-bordered tbody:first-child tr:first-child>th:last-child{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-moz-border-radius-topright:4px}.table-bordered thead:last-child tr:last-child>th:first-child,.table-bordered tbody:last-child tr:last-child>td:first-child,.table-bordered tbody:last-child tr:last-child>th:first-child,.table-bordered tfoot:last-child tr:last-child>td:first-child,.table-bordered tfoot:last-child tr:last-child>th:first-child{-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-moz-border-radius-bottomleft:4px}.table-bordered thead:last-child tr:last-child>th:last-child,.table-bordered tbody:last-child tr:last-child>td:last-child,.table-bordered tbody:last-child tr:last-child>th:last-child,.table-bordered tfoot:last-child tr:last-child>td:last-child,.table-bordered tfoot:last-child tr:last-child>th:last-child{-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-moz-border-radius-bottomright:4px}.table-bordered tfoot+tbody:last-child tr:last-child td:first-child{-webkit-border-bottom-left-radius:0;border-bottom-left-radius:0;-moz-border-radius-bottomleft:0}.table-bordered tfoot+tbody:last-child tr:last-child td:last-child{-webkit-border-bottom-right-radius:0;border-bottom-right-radius:0;-moz-border-radius-bottomright:0}.table-bordered caption+thead tr:first-child th:first-child,.table-bordered caption+tbody tr:first-child td:first-child,.table-bordered colgroup+thead tr:first-child th:first-child,.table-bordered colgroup+tbody tr:first-child td:first-child{-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-topleft:4px}.table-bordered caption+thead tr:first-child th:last-child,.table-bordered caption+tbody tr:first-child td:last-child,.table-bordered colgroup+thead tr:first-child th:last-child,.table-bordered colgroup+tbody tr:first-child td:last-child{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-moz-border-radius-topright:4px}.table-striped tbody>tr:nth-child(odd)>td,.table-striped tbody>tr:nth-child(odd)>th{background-color:#f9f9f9}.table-hover tbody tr:hover>td,.table-hover tbody tr:hover>th{background-color:#f5f5f5}table td[class*="span"],table th[class*="span"],.row-fluid table td[class*="span"],.row-fluid table th[class*="span"]{display:table-cell;float:none;margin-left:0}.table td.span1,.table th.span1{float:none;width:44px;margin-left:0}.table td.span2,.table th.span2{float:none;width:124px;margin-left:0}.table td.span3,.table th.span3{float:none;width:204px;margin-left:0}.table td.span4,.table th.span4{float:none;width:284px;margin-left:0}.table td.span5,.table th.span5{float:none;width:364px;margin-left:0}.table td.span6,.table th.span6{float:none;width:444px;margin-left:0}.table td.span7,.table th.span7{float:none;width:524px;margin-left:0}.table td.span8,.table th.span8{float:none;width:604px;margin-left:0}.table td.span9,.table th.span9{float:none;width:684px;margin-left:0}.table td.span10,.table th.span10{float:none;width:764px;margin-left:0}.table td.span11,.table th.span11{float:none;width:844px;margin-left:0}.table td.span12,.table th.span12{float:none;width:924px;margin-left:0}.table tbody tr.success>td{background-color:#dff0d8}.table tbody tr.error>td{background-color:#f2dede}.table tbody tr.warning>td{background-color:#fcf8e3}.table tbody tr.info>td{background-color:#d9edf7}.table-hover tbody tr.success:hover>td{background-color:#d0e9c6}.table-hover tbody tr.error:hover>td{background-color:#ebcccc}.table-hover tbody tr.warning:hover>td{background-color:#faf2cc}.table-hover tbody tr.info:hover>td{background-color:#c4e3f3}[class^="icon-"],[class*=" icon-"]{display:inline-block;width:14px;height:14px;margin-top:1px;*margin-right:.3em;line-height:14px;vertical-align:text-top;background-image:url("../img/glyphicons-halflings.png");background-position:14px 14px;background-repeat:no-repeat}.icon-white,.nav-pills>.active>a>[class^="icon-"],.nav-pills>.active>a>[class*=" icon-"],.nav-list>.active>a>[class^="icon-"],.nav-list>.active>a>[class*=" icon-"],.navbar-inverse .nav>.active>a>[class^="icon-"],.navbar-inverse .nav>.active>a>[class*=" icon-"],.dropdown-menu>li>a:hover>[class^="icon-"],.dropdown-menu>li>a:focus>[class^="icon-"],.dropdown-menu>li>a:hover>[class*=" icon-"],.dropdown-menu>li>a:focus>[class*=" icon-"],.dropdown-menu>.active>a>[class^="icon-"],.dropdown-menu>.active>a>[class*=" icon-"],.dropdown-submenu:hover>a>[class^="icon-"],.dropdown-submenu:focus>a>[class^="icon-"],.dropdown-submenu:hover>a>[class*=" icon-"],.dropdown-submenu:focus>a>[class*=" icon-"]{background-image:url("../img/glyphicons-halflings-white.png")}.icon-glass{background-position:0 0}.icon-music{background-position:-24px 0}.icon-search{background-position:-48px 0}.icon-envelope{background-position:-72px 0}.icon-heart{background-position:-96px 0}.icon-star{background-position:-120px 0}.icon-star-empty{background-position:-144px 0}.icon-user{background-position:-168px 0}.icon-film{background-position:-192px 0}.icon-th-large{background-position:-216px 0}.icon-th{background-position:-240px 0}.icon-th-list{background-position:-264px 0}.icon-ok{background-position:-288px 0}.icon-remove{background-position:-312px 0}.icon-zoom-in{background-position:-336px 0}.icon-zoom-out{background-position:-360px 0}.icon-off{background-position:-384px 0}.icon-signal{background-position:-408px 0}.icon-cog{background-position:-432px 0}.icon-trash{background-position:-456px 0}.icon-home{background-position:0 -24px}.icon-file{background-position:-24px -24px}.icon-time{background-position:-48px -24px}.icon-road{background-position:-72px -24px}.icon-download-alt{background-position:-96px -24px}.icon-download{background-position:-120px -24px}.icon-upload{background-position:-144px -24px}.icon-inbox{background-position:-168px -24px}.icon-play-circle{background-position:-192px -24px}.icon-repeat{background-position:-216px -24px}.icon-refresh{background-position:-240px -24px}.icon-list-alt{background-position:-264px -24px}.icon-lock{background-position:-287px -24px}.icon-flag{background-position:-312px -24px}.icon-headphones{background-position:-336px -24px}.icon-volume-off{background-position:-360px -24px}.icon-volume-down{background-position:-384px -24px}.icon-volume-up{background-position:-408px -24px}.icon-qrcode{background-position:-432px -24px}.icon-barcode{background-position:-456px -24px}.icon-tag{background-position:0 -48px}.icon-tags{background-position:-25px -48px}.icon-book{background-position:-48px -48px}.icon-bookmark{background-position:-72px -48px}.icon-print{background-position:-96px -48px}.icon-camera{background-position:-120px -48px}.icon-font{background-position:-144px -48px}.icon-bold{background-position:-167px -48px}.icon-italic{background-position:-192px -48px}.icon-text-height{background-position:-216px -48px}.icon-text-width{background-position:-240px -48px}.icon-align-left{background-position:-264px -48px}.icon-align-center{background-position:-288px -48px}.icon-align-right{background-position:-312px -48px}.icon-align-justify{background-position:-336px -48px}.icon-list{background-position:-360px -48px}.icon-indent-left{background-position:-384px -48px}.icon-indent-right{background-position:-408px -48px}.icon-facetime-video{background-position:-432px -48px}.icon-picture{background-position:-456px -48px}.icon-pencil{background-position:0 -72px}.icon-map-marker{background-position:-24px -72px}.icon-adjust{background-position:-48px -72px}.icon-tint{background-position:-72px -72px}.icon-edit{background-position:-96px -72px}.icon-share{background-position:-120px -72px}.icon-check{background-position:-144px -72px}.icon-move{background-position:-168px -72px}.icon-step-backward{background-position:-192px -72px}.icon-fast-backward{background-position:-216px -72px}.icon-backward{background-position:-240px -72px}.icon-play{background-position:-264px -72px}.icon-pause{background-position:-288px -72px}.icon-stop{background-position:-312px -72px}.icon-forward{background-position:-336px -72px}.icon-fast-forward{background-position:-360px -72px}.icon-step-forward{background-position:-384px -72px}.icon-eject{background-position:-408px -72px}.icon-chevron-left{background-position:-432px -72px}.icon-chevron-right{background-position:-456px -72px}.icon-plus-sign{background-position:0 -96px}.icon-minus-sign{background-position:-24px -96px}.icon-remove-sign{background-position:-48px -96px}.icon-ok-sign{background-position:-72px -96px}.icon-question-sign{background-position:-96px -96px}.icon-info-sign{background-position:-120px -96px}.icon-screenshot{background-position:-144px -96px}.icon-remove-circle{background-position:-168px -96px}.icon-ok-circle{background-position:-192px -96px}.icon-ban-circle{background-position:-216px -96px}.icon-arrow-left{background-position:-240px -96px}.icon-arrow-right{background-position:-264px -96px}.icon-arrow-up{background-position:-289px -96px}.icon-arrow-down{background-position:-312px -96px}.icon-share-alt{background-position:-336px -96px}.icon-resize-full{background-position:-360px -96px}.icon-resize-small{background-position:-384px -96px}.icon-plus{background-position:-408px -96px}.icon-minus{background-position:-433px -96px}.icon-asterisk{background-position:-456px -96px}.icon-exclamation-sign{background-position:0 -120px}.icon-gift{background-position:-24px -120px}.icon-leaf{background-position:-48px -120px}.icon-fire{background-position:-72px -120px}.icon-eye-open{background-position:-96px -120px}.icon-eye-close{background-position:-120px -120px}.icon-warning-sign{background-position:-144px -120px}.icon-plane{background-position:-168px -120px}.icon-calendar{background-position:-192px -120px}.icon-random{width:16px;background-position:-216px -120px}.icon-comment{background-position:-240px -120px}.icon-magnet{background-position:-264px -120px}.icon-chevron-up{background-position:-288px -120px}.icon-chevron-down{background-position:-313px -119px}.icon-retweet{background-position:-336px -120px}.icon-shopping-cart{background-position:-360px -120px}.icon-folder-close{width:16px;background-position:-384px -120px}.icon-folder-open{width:16px;background-position:-408px -120px}.icon-resize-vertical{background-position:-432px -119px}.icon-resize-horizontal{background-position:-456px -118px}.icon-hdd{background-position:0 -144px}.icon-bullhorn{background-position:-24px -144px}.icon-bell{background-position:-48px -144px}.icon-certificate{background-position:-72px -144px}.icon-thumbs-up{background-position:-96px -144px}.icon-thumbs-down{background-position:-120px -144px}.icon-hand-right{background-position:-144px -144px}.icon-hand-left{background-position:-168px -144px}.icon-hand-up{background-position:-192px -144px}.icon-hand-down{background-position:-216px -144px}.icon-circle-arrow-right{background-position:-240px -144px}.icon-circle-arrow-left{background-position:-264px -144px}.icon-circle-arrow-up{background-position:-288px -144px}.icon-circle-arrow-down{background-position:-312px -144px}.icon-globe{background-position:-336px -144px}.icon-wrench{background-position:-360px -144px}.icon-tasks{background-position:-384px -144px}.icon-filter{background-position:-408px -144px}.icon-briefcase{background-position:-432px -144px}.icon-fullscreen{background-position:-456px -144px}.dropup,.dropdown{position:relative}.dropdown-toggle{*margin-bottom:-3px}.dropdown-toggle:active,.open .dropdown-toggle{outline:0}.caret{display:inline-block;width:0;height:0;vertical-align:top;border-top:4px solid #000;border-right:4px solid transparent;border-left:4px solid transparent;content:""}.dropdown .caret{margin-top:8px;margin-left:2px}.dropdown-menu{position:absolute;top:100%;left:0;z-index:1000;display:none;float:left;min-width:160px;padding:5px 0;margin:2px 0 0;list-style:none;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.2);*border-right-width:2px;*border-bottom-width:2px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,0.2);-moz-box-shadow:0 5px 10px rgba(0,0,0,0.2);box-shadow:0 5px 10px rgba(0,0,0,0.2);-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box}.dropdown-menu.pull-right{right:0;left:auto}.dropdown-menu .divider{*width:100%;height:1px;margin:9px 1px;*margin:-5px 0 5px;overflow:hidden;background-color:#e5e5e5;border-bottom:1px solid #fff}.dropdown-menu>li>a{display:block;padding:3px 20px;clear:both;font-weight:normal;line-height:20px;color:#333;white-space:nowrap}.dropdown-menu>li>a:hover,.dropdown-menu>li>a:focus,.dropdown-submenu:hover>a,.dropdown-submenu:focus>a{color:#fff;text-decoration:none;background-color:#0081c2;background-image:-moz-linear-gradient(top,#08c,#0077b3);background-image:-webkit-gradient(linear,0 0,0 100%,from(#08c),to(#0077b3));background-image:-webkit-linear-gradient(top,#08c,#0077b3);background-image:-o-linear-gradient(top,#08c,#0077b3);background-image:linear-gradient(to bottom,#08c,#0077b3);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc',endColorstr='#ff0077b3',GradientType=0)}.dropdown-menu>.active>a,.dropdown-menu>.active>a:hover,.dropdown-menu>.active>a:focus{color:#fff;text-decoration:none;background-color:#0081c2;background-image:-moz-linear-gradient(top,#08c,#0077b3);background-image:-webkit-gradient(linear,0 0,0 100%,from(#08c),to(#0077b3));background-image:-webkit-linear-gradient(top,#08c,#0077b3);background-image:-o-linear-gradient(top,#08c,#0077b3);background-image:linear-gradient(to bottom,#08c,#0077b3);background-repeat:repeat-x;outline:0;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc',endColorstr='#ff0077b3',GradientType=0)}.dropdown-menu>.disabled>a,.dropdown-menu>.disabled>a:hover,.dropdown-menu>.disabled>a:focus{color:#999}.dropdown-menu>.disabled>a:hover,.dropdown-menu>.disabled>a:focus{text-decoration:none;cursor:default;background-color:transparent;background-image:none;filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.open{*z-index:1000}.open>.dropdown-menu{display:block}.dropdown-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:990}.pull-right>.dropdown-menu{right:0;left:auto}.dropup .caret,.navbar-fixed-bottom .dropdown .caret{border-top:0;border-bottom:4px solid #000;content:""}.dropup .dropdown-menu,.navbar-fixed-bottom .dropdown .dropdown-menu{top:auto;bottom:100%;margin-bottom:1px}.dropdown-submenu{position:relative}.dropdown-submenu>.dropdown-menu{top:0;left:100%;margin-top:-6px;margin-left:-1px;-webkit-border-radius:0 6px 6px 6px;-moz-border-radius:0 6px 6px 6px;border-radius:0 6px 6px 6px}.dropdown-submenu:hover>.dropdown-menu{display:block}.dropup .dropdown-submenu>.dropdown-menu{top:auto;bottom:0;margin-top:0;margin-bottom:-2px;-webkit-border-radius:5px 5px 5px 0;-moz-border-radius:5px 5px 5px 0;border-radius:5px 5px 5px 0}.dropdown-submenu>a:after{display:block;float:right;width:0;height:0;margin-top:5px;margin-right:-10px;border-color:transparent;border-left-color:#ccc;border-style:solid;border-width:5px 0 5px 5px;content:" "}.dropdown-submenu:hover>a:after{border-left-color:#fff}.dropdown-submenu.pull-left{float:none}.dropdown-submenu.pull-left>.dropdown-menu{left:-100%;margin-left:10px;-webkit-border-radius:6px 0 6px 6px;-moz-border-radius:6px 0 6px 6px;border-radius:6px 0 6px 6px}.dropdown .dropdown-menu .nav-header{padding-right:20px;padding-left:20px}.typeahead{z-index:1051;margin-top:2px;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.well{min-height:20px;padding:19px;margin-bottom:20px;background-color:#f5f5f5;border:1px solid #e3e3e3;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:inset 0 1px 1px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 1px 1px rgba(0,0,0,0.05);box-shadow:inset 0 1px 1px rgba(0,0,0,0.05)}.well blockquote{border-color:#ddd;border-color:rgba(0,0,0,0.15)}.well-large{padding:24px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.well-small{padding:9px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.fade{opacity:0;-webkit-transition:opacity .15s linear;-moz-transition:opacity .15s linear;-o-transition:opacity .15s linear;transition:opacity .15s linear}.fade.in{opacity:1}.collapse{position:relative;height:0;overflow:hidden;-webkit-transition:height .35s ease;-moz-transition:height .35s ease;-o-transition:height .35s ease;transition:height .35s ease}.collapse.in{height:auto}.close{float:right;font-size:20px;font-weight:bold;line-height:20px;color:#000;text-shadow:0 1px 0 #fff;opacity:.2;filter:alpha(opacity=20)}.close:hover,.close:focus{color:#000;text-decoration:none;cursor:pointer;opacity:.4;filter:alpha(opacity=40)}button.close{padding:0;cursor:pointer;background:transparent;border:0;-webkit-appearance:none}.btn{display:inline-block;*display:inline;padding:4px 12px;margin-bottom:0;*margin-left:.3em;font-size:14px;line-height:20px;color:#333;text-align:center;text-shadow:0 1px 1px rgba(255,255,255,0.75);vertical-align:middle;cursor:pointer;background-color:#f5f5f5;*background-color:#e6e6e6;background-image:-moz-linear-gradient(top,#fff,#e6e6e6);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#e6e6e6));background-image:-webkit-linear-gradient(top,#fff,#e6e6e6);background-image:-o-linear-gradient(top,#fff,#e6e6e6);background-image:linear-gradient(to bottom,#fff,#e6e6e6);background-repeat:repeat-x;border:1px solid #ccc;*border:0;border-color:#e6e6e6 #e6e6e6 #bfbfbf;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);border-bottom-color:#b3b3b3;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff',endColorstr='#ffe6e6e6',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);*zoom:1;-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05)}.btn:hover,.btn:focus,.btn:active,.btn.active,.btn.disabled,.btn[disabled]{color:#333;background-color:#e6e6e6;*background-color:#d9d9d9}.btn:active,.btn.active{background-color:#ccc \9}.btn:first-child{*margin-left:0}.btn:hover,.btn:focus{color:#333;text-decoration:none;background-position:0 -15px;-webkit-transition:background-position .1s linear;-moz-transition:background-position .1s linear;-o-transition:background-position .1s linear;transition:background-position .1s linear}.btn:focus{outline:thin dotted #333;outline:5px auto -webkit-focus-ring-color;outline-offset:-2px}.btn.active,.btn:active{background-image:none;outline:0;-webkit-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05)}.btn.disabled,.btn[disabled]{cursor:default;background-image:none;opacity:.65;filter:alpha(opacity=65);-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none}.btn-large{padding:11px 19px;font-size:17.5px;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.btn-large [class^="icon-"],.btn-large [class*=" icon-"]{margin-top:4px}.btn-small{padding:2px 10px;font-size:11.9px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.btn-small [class^="icon-"],.btn-small [class*=" icon-"]{margin-top:0}.btn-mini [class^="icon-"],.btn-mini [class*=" icon-"]{margin-top:-1px}.btn-mini{padding:0 6px;font-size:10.5px;-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.btn-block{display:block;width:100%;padding-right:0;padding-left:0;-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box}.btn-block+.btn-block{margin-top:5px}input[type="submit"].btn-block,input[type="reset"].btn-block,input[type="button"].btn-block{width:100%}.btn-primary.active,.btn-warning.active,.btn-danger.active,.btn-success.active,.btn-info.active,.btn-inverse.active{color:rgba(255,255,255,0.75)}.btn-primary{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#006dcc;*background-color:#04c;background-image:-moz-linear-gradient(top,#08c,#04c);background-image:-webkit-gradient(linear,0 0,0 100%,from(#08c),to(#04c));background-image:-webkit-linear-gradient(top,#08c,#04c);background-image:-o-linear-gradient(top,#08c,#04c);background-image:linear-gradient(to bottom,#08c,#04c);background-repeat:repeat-x;border-color:#04c #04c #002a80;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff0088cc',endColorstr='#ff0044cc',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.btn-primary:hover,.btn-primary:focus,.btn-primary:active,.btn-primary.active,.btn-primary.disabled,.btn-primary[disabled]{color:#fff;background-color:#04c;*background-color:#003bb3}.btn-primary:active,.btn-primary.active{background-color:#039 \9}.btn-warning{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#faa732;*background-color:#f89406;background-image:-moz-linear-gradient(top,#fbb450,#f89406);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fbb450),to(#f89406));background-image:-webkit-linear-gradient(top,#fbb450,#f89406);background-image:-o-linear-gradient(top,#fbb450,#f89406);background-image:linear-gradient(to bottom,#fbb450,#f89406);background-repeat:repeat-x;border-color:#f89406 #f89406 #ad6704;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffbb450',endColorstr='#fff89406',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.btn-warning:hover,.btn-warning:focus,.btn-warning:active,.btn-warning.active,.btn-warning.disabled,.btn-warning[disabled]{color:#fff;background-color:#f89406;*background-color:#df8505}.btn-warning:active,.btn-warning.active{background-color:#c67605 \9}.btn-danger{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#da4f49;*background-color:#bd362f;background-image:-moz-linear-gradient(top,#ee5f5b,#bd362f);background-image:-webkit-gradient(linear,0 0,0 100%,from(#ee5f5b),to(#bd362f));background-image:-webkit-linear-gradient(top,#ee5f5b,#bd362f);background-image:-o-linear-gradient(top,#ee5f5b,#bd362f);background-image:linear-gradient(to bottom,#ee5f5b,#bd362f);background-repeat:repeat-x;border-color:#bd362f #bd362f #802420;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b',endColorstr='#ffbd362f',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.btn-danger:hover,.btn-danger:focus,.btn-danger:active,.btn-danger.active,.btn-danger.disabled,.btn-danger[disabled]{color:#fff;background-color:#bd362f;*background-color:#a9302a}.btn-danger:active,.btn-danger.active{background-color:#942a25 \9}.btn-success{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#5bb75b;*background-color:#51a351;background-image:-moz-linear-gradient(top,#62c462,#51a351);background-image:-webkit-gradient(linear,0 0,0 100%,from(#62c462),to(#51a351));background-image:-webkit-linear-gradient(top,#62c462,#51a351);background-image:-o-linear-gradient(top,#62c462,#51a351);background-image:linear-gradient(to bottom,#62c462,#51a351);background-repeat:repeat-x;border-color:#51a351 #51a351 #387038;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462',endColorstr='#ff51a351',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.btn-success:hover,.btn-success:focus,.btn-success:active,.btn-success.active,.btn-success.disabled,.btn-success[disabled]{color:#fff;background-color:#51a351;*background-color:#499249}.btn-success:active,.btn-success.active{background-color:#408140 \9}.btn-info{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#49afcd;*background-color:#2f96b4;background-image:-moz-linear-gradient(top,#5bc0de,#2f96b4);background-image:-webkit-gradient(linear,0 0,0 100%,from(#5bc0de),to(#2f96b4));background-image:-webkit-linear-gradient(top,#5bc0de,#2f96b4);background-image:-o-linear-gradient(top,#5bc0de,#2f96b4);background-image:linear-gradient(to bottom,#5bc0de,#2f96b4);background-repeat:repeat-x;border-color:#2f96b4 #2f96b4 #1f6377;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de',endColorstr='#ff2f96b4',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.btn-info:hover,.btn-info:focus,.btn-info:active,.btn-info.active,.btn-info.disabled,.btn-info[disabled]{color:#fff;background-color:#2f96b4;*background-color:#2a85a0}.btn-info:active,.btn-info.active{background-color:#24748c \9}.btn-inverse{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#363636;*background-color:#222;background-image:-moz-linear-gradient(top,#444,#222);background-image:-webkit-gradient(linear,0 0,0 100%,from(#444),to(#222));background-image:-webkit-linear-gradient(top,#444,#222);background-image:-o-linear-gradient(top,#444,#222);background-image:linear-gradient(to bottom,#444,#222);background-repeat:repeat-x;border-color:#222 #222 #000;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff444444',endColorstr='#ff222222',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.btn-inverse:hover,.btn-inverse:focus,.btn-inverse:active,.btn-inverse.active,.btn-inverse.disabled,.btn-inverse[disabled]{color:#fff;background-color:#222;*background-color:#151515}.btn-inverse:active,.btn-inverse.active{background-color:#080808 \9}button.btn,input[type="submit"].btn{*padding-top:3px;*padding-bottom:3px}button.btn::-moz-focus-inner,input[type="submit"].btn::-moz-focus-inner{padding:0;border:0}button.btn.btn-large,input[type="submit"].btn.btn-large{*padding-top:7px;*padding-bottom:7px}button.btn.btn-small,input[type="submit"].btn.btn-small{*padding-top:3px;*padding-bottom:3px}button.btn.btn-mini,input[type="submit"].btn.btn-mini{*padding-top:1px;*padding-bottom:1px}.btn-link,.btn-link:active,.btn-link[disabled]{background-color:transparent;background-image:none;-webkit-box-shadow:none;-moz-box-shadow:none;box-shadow:none}.btn-link{color:#08c;cursor:pointer;border-color:transparent;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.btn-link:hover,.btn-link:focus{color:#005580;text-decoration:underline;background-color:transparent}.btn-link[disabled]:hover,.btn-link[disabled]:focus{color:#333;text-decoration:none}.btn-group{position:relative;display:inline-block;*display:inline;*margin-left:.3em;font-size:0;white-space:nowrap;vertical-align:middle;*zoom:1}.btn-group:first-child{*margin-left:0}.btn-group+.btn-group{margin-left:5px}.btn-toolbar{margin-top:10px;margin-bottom:10px;font-size:0}.btn-toolbar>.btn+.btn,.btn-toolbar>.btn-group+.btn,.btn-toolbar>.btn+.btn-group{margin-left:5px}.btn-group>.btn{position:relative;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.btn-group>.btn+.btn{margin-left:-1px}.btn-group>.btn,.btn-group>.dropdown-menu,.btn-group>.popover{font-size:14px}.btn-group>.btn-mini{font-size:10.5px}.btn-group>.btn-small{font-size:11.9px}.btn-group>.btn-large{font-size:17.5px}.btn-group>.btn:first-child{margin-left:0;-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-bottomleft:4px;-moz-border-radius-topleft:4px}.btn-group>.btn:last-child,.btn-group>.dropdown-toggle{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-moz-border-radius-topright:4px;-moz-border-radius-bottomright:4px}.btn-group>.btn.large:first-child{margin-left:0;-webkit-border-bottom-left-radius:6px;border-bottom-left-radius:6px;-webkit-border-top-left-radius:6px;border-top-left-radius:6px;-moz-border-radius-bottomleft:6px;-moz-border-radius-topleft:6px}.btn-group>.btn.large:last-child,.btn-group>.large.dropdown-toggle{-webkit-border-top-right-radius:6px;border-top-right-radius:6px;-webkit-border-bottom-right-radius:6px;border-bottom-right-radius:6px;-moz-border-radius-topright:6px;-moz-border-radius-bottomright:6px}.btn-group>.btn:hover,.btn-group>.btn:focus,.btn-group>.btn:active,.btn-group>.btn.active{z-index:2}.btn-group .dropdown-toggle:active,.btn-group.open .dropdown-toggle{outline:0}.btn-group>.btn+.dropdown-toggle{*padding-top:5px;padding-right:8px;*padding-bottom:5px;padding-left:8px;-webkit-box-shadow:inset 1px 0 0 rgba(255,255,255,0.125),inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 1px 0 0 rgba(255,255,255,0.125),inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 1px 0 0 rgba(255,255,255,0.125),inset 0 1px 0 rgba(255,255,255,0.2),0 1px 2px rgba(0,0,0,0.05)}.btn-group>.btn-mini+.dropdown-toggle{*padding-top:2px;padding-right:5px;*padding-bottom:2px;padding-left:5px}.btn-group>.btn-small+.dropdown-toggle{*padding-top:5px;*padding-bottom:4px}.btn-group>.btn-large+.dropdown-toggle{*padding-top:7px;padding-right:12px;*padding-bottom:7px;padding-left:12px}.btn-group.open .dropdown-toggle{background-image:none;-webkit-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05);box-shadow:inset 0 2px 4px rgba(0,0,0,0.15),0 1px 2px rgba(0,0,0,0.05)}.btn-group.open .btn.dropdown-toggle{background-color:#e6e6e6}.btn-group.open .btn-primary.dropdown-toggle{background-color:#04c}.btn-group.open .btn-warning.dropdown-toggle{background-color:#f89406}.btn-group.open .btn-danger.dropdown-toggle{background-color:#bd362f}.btn-group.open .btn-success.dropdown-toggle{background-color:#51a351}.btn-group.open .btn-info.dropdown-toggle{background-color:#2f96b4}.btn-group.open .btn-inverse.dropdown-toggle{background-color:#222}.btn .caret{margin-top:8px;margin-left:0}.btn-large .caret{margin-top:6px}.btn-large .caret{border-top-width:5px;border-right-width:5px;border-left-width:5px}.btn-mini .caret,.btn-small .caret{margin-top:8px}.dropup .btn-large .caret{border-bottom-width:5px}.btn-primary .caret,.btn-warning .caret,.btn-danger .caret,.btn-info .caret,.btn-success .caret,.btn-inverse .caret{border-top-color:#fff;border-bottom-color:#fff}.btn-group-vertical{display:inline-block;*display:inline;*zoom:1}.btn-group-vertical>.btn{display:block;float:none;max-width:100%;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.btn-group-vertical>.btn+.btn{margin-top:-1px;margin-left:0}.btn-group-vertical>.btn:first-child{-webkit-border-radius:4px 4px 0 0;-moz-border-radius:4px 4px 0 0;border-radius:4px 4px 0 0}.btn-group-vertical>.btn:last-child{-webkit-border-radius:0 0 4px 4px;-moz-border-radius:0 0 4px 4px;border-radius:0 0 4px 4px}.btn-group-vertical>.btn-large:first-child{-webkit-border-radius:6px 6px 0 0;-moz-border-radius:6px 6px 0 0;border-radius:6px 6px 0 0}.btn-group-vertical>.btn-large:last-child{-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px}.alert{padding:8px 35px 8px 14px;margin-bottom:20px;text-shadow:0 1px 0 rgba(255,255,255,0.5);background-color:#fcf8e3;border:1px solid #fbeed5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.alert,.alert h4{color:#c09853}.alert h4{margin:0}.alert .close{position:relative;top:-2px;right:-21px;line-height:20px}.alert-success{color:#468847;background-color:#dff0d8;border-color:#d6e9c6}.alert-success h4{color:#468847}.alert-danger,.alert-error{color:#b94a48;background-color:#f2dede;border-color:#eed3d7}.alert-danger h4,.alert-error h4{color:#b94a48}.alert-info{color:#3a87ad;background-color:#d9edf7;border-color:#bce8f1}.alert-info h4{color:#3a87ad}.alert-block{padding-top:14px;padding-bottom:14px}.alert-block>p,.alert-block>ul{margin-bottom:0}.alert-block p+p{margin-top:5px}.nav{margin-bottom:20px;margin-left:0;list-style:none}.nav>li>a{display:block}.nav>li>a:hover,.nav>li>a:focus{text-decoration:none;background-color:#eee}.nav>li>a>img{max-width:none}.nav>.pull-right{float:right}.nav-header{display:block;padding:3px 15px;font-size:11px;font-weight:bold;line-height:20px;color:#999;text-shadow:0 1px 0 rgba(255,255,255,0.5);text-transform:uppercase}.nav li+.nav-header{margin-top:9px}.nav-list{padding-right:15px;padding-left:15px;margin-bottom:0}.nav-list>li>a,.nav-list .nav-header{margin-right:-15px;margin-left:-15px;text-shadow:0 1px 0 rgba(255,255,255,0.5)}.nav-list>li>a{padding:3px 15px}.nav-list>.active>a,.nav-list>.active>a:hover,.nav-list>.active>a:focus{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.2);background-color:#08c}.nav-list [class^="icon-"],.nav-list [class*=" icon-"]{margin-right:2px}.nav-list .divider{*width:100%;height:1px;margin:9px 1px;*margin:-5px 0 5px;overflow:hidden;background-color:#e5e5e5;border-bottom:1px solid #fff}.nav-tabs,.nav-pills{*zoom:1}.nav-tabs:before,.nav-pills:before,.nav-tabs:after,.nav-pills:after{display:table;line-height:0;content:""}.nav-tabs:after,.nav-pills:after{clear:both}.nav-tabs>li,.nav-pills>li{float:left}.nav-tabs>li>a,.nav-pills>li>a{padding-right:12px;padding-left:12px;margin-right:2px;line-height:14px}.nav-tabs{border-bottom:1px solid #ddd}.nav-tabs>li{margin-bottom:-1px}.nav-tabs>li>a{padding-top:8px;padding-bottom:8px;line-height:20px;border:1px solid transparent;-webkit-border-radius:4px 4px 0 0;-moz-border-radius:4px 4px 0 0;border-radius:4px 4px 0 0}.nav-tabs>li>a:hover,.nav-tabs>li>a:focus{border-color:#eee #eee #ddd}.nav-tabs>.active>a,.nav-tabs>.active>a:hover,.nav-tabs>.active>a:focus{color:#555;cursor:default;background-color:#fff;border:1px solid #ddd;border-bottom-color:transparent}.nav-pills>li>a{padding-top:8px;padding-bottom:8px;margin-top:2px;margin-bottom:2px;-webkit-border-radius:5px;-moz-border-radius:5px;border-radius:5px}.nav-pills>.active>a,.nav-pills>.active>a:hover,.nav-pills>.active>a:focus{color:#fff;background-color:#08c}.nav-stacked>li{float:none}.nav-stacked>li>a{margin-right:0}.nav-tabs.nav-stacked{border-bottom:0}.nav-tabs.nav-stacked>li>a{border:1px solid #ddd;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.nav-tabs.nav-stacked>li:first-child>a{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-topright:4px;-moz-border-radius-topleft:4px}.nav-tabs.nav-stacked>li:last-child>a{-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-moz-border-radius-bottomright:4px;-moz-border-radius-bottomleft:4px}.nav-tabs.nav-stacked>li>a:hover,.nav-tabs.nav-stacked>li>a:focus{z-index:2;border-color:#ddd}.nav-pills.nav-stacked>li>a{margin-bottom:3px}.nav-pills.nav-stacked>li:last-child>a{margin-bottom:1px}.nav-tabs .dropdown-menu{-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px}.nav-pills .dropdown-menu{-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.nav .dropdown-toggle .caret{margin-top:6px;border-top-color:#08c;border-bottom-color:#08c}.nav .dropdown-toggle:hover .caret,.nav .dropdown-toggle:focus .caret{border-top-color:#005580;border-bottom-color:#005580}.nav-tabs .dropdown-toggle .caret{margin-top:8px}.nav .active .dropdown-toggle .caret{border-top-color:#fff;border-bottom-color:#fff}.nav-tabs .active .dropdown-toggle .caret{border-top-color:#555;border-bottom-color:#555}.nav>.dropdown.active>a:hover,.nav>.dropdown.active>a:focus{cursor:pointer}.nav-tabs .open .dropdown-toggle,.nav-pills .open .dropdown-toggle,.nav>li.dropdown.open.active>a:hover,.nav>li.dropdown.open.active>a:focus{color:#fff;background-color:#999;border-color:#999}.nav li.dropdown.open .caret,.nav li.dropdown.open.active .caret,.nav li.dropdown.open a:hover .caret,.nav li.dropdown.open a:focus .caret{border-top-color:#fff;border-bottom-color:#fff;opacity:1;filter:alpha(opacity=100)}.tabs-stacked .open>a:hover,.tabs-stacked .open>a:focus{border-color:#999}.tabbable{*zoom:1}.tabbable:before,.tabbable:after{display:table;line-height:0;content:""}.tabbable:after{clear:both}.tab-content{overflow:auto}.tabs-below>.nav-tabs,.tabs-right>.nav-tabs,.tabs-left>.nav-tabs{border-bottom:0}.tab-content>.tab-pane,.pill-content>.pill-pane{display:none}.tab-content>.active,.pill-content>.active{display:block}.tabs-below>.nav-tabs{border-top:1px solid #ddd}.tabs-below>.nav-tabs>li{margin-top:-1px;margin-bottom:0}.tabs-below>.nav-tabs>li>a{-webkit-border-radius:0 0 4px 4px;-moz-border-radius:0 0 4px 4px;border-radius:0 0 4px 4px}.tabs-below>.nav-tabs>li>a:hover,.tabs-below>.nav-tabs>li>a:focus{border-top-color:#ddd;border-bottom-color:transparent}.tabs-below>.nav-tabs>.active>a,.tabs-below>.nav-tabs>.active>a:hover,.tabs-below>.nav-tabs>.active>a:focus{border-color:transparent #ddd #ddd #ddd}.tabs-left>.nav-tabs>li,.tabs-right>.nav-tabs>li{float:none}.tabs-left>.nav-tabs>li>a,.tabs-right>.nav-tabs>li>a{min-width:74px;margin-right:0;margin-bottom:3px}.tabs-left>.nav-tabs{float:left;margin-right:19px;border-right:1px solid #ddd}.tabs-left>.nav-tabs>li>a{margin-right:-1px;-webkit-border-radius:4px 0 0 4px;-moz-border-radius:4px 0 0 4px;border-radius:4px 0 0 4px}.tabs-left>.nav-tabs>li>a:hover,.tabs-left>.nav-tabs>li>a:focus{border-color:#eee #ddd #eee #eee}.tabs-left>.nav-tabs .active>a,.tabs-left>.nav-tabs .active>a:hover,.tabs-left>.nav-tabs .active>a:focus{border-color:#ddd transparent #ddd #ddd;*border-right-color:#fff}.tabs-right>.nav-tabs{float:right;margin-left:19px;border-left:1px solid #ddd}.tabs-right>.nav-tabs>li>a{margin-left:-1px;-webkit-border-radius:0 4px 4px 0;-moz-border-radius:0 4px 4px 0;border-radius:0 4px 4px 0}.tabs-right>.nav-tabs>li>a:hover,.tabs-right>.nav-tabs>li>a:focus{border-color:#eee #eee #eee #ddd}.tabs-right>.nav-tabs .active>a,.tabs-right>.nav-tabs .active>a:hover,.tabs-right>.nav-tabs .active>a:focus{border-color:#ddd #ddd #ddd transparent;*border-left-color:#fff}.nav>.disabled>a{color:#999}.nav>.disabled>a:hover,.nav>.disabled>a:focus{text-decoration:none;cursor:default;background-color:transparent}.navbar{*position:relative;*z-index:2;margin-bottom:20px;overflow:visible}.navbar-inner{min-height:40px;padding-right:20px;padding-left:20px;background-color:#fafafa;background-image:-moz-linear-gradient(top,#fff,#f2f2f2);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fff),to(#f2f2f2));background-image:-webkit-linear-gradient(top,#fff,#f2f2f2);background-image:-o-linear-gradient(top,#fff,#f2f2f2);background-image:linear-gradient(to bottom,#fff,#f2f2f2);background-repeat:repeat-x;border:1px solid #d4d4d4;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffffffff',endColorstr='#fff2f2f2',GradientType=0);*zoom:1;-webkit-box-shadow:0 1px 4px rgba(0,0,0,0.065);-moz-box-shadow:0 1px 4px rgba(0,0,0,0.065);box-shadow:0 1px 4px rgba(0,0,0,0.065)}.navbar-inner:before,.navbar-inner:after{display:table;line-height:0;content:""}.navbar-inner:after{clear:both}.navbar .container{width:auto}.nav-collapse.collapse{height:auto;overflow:visible}.navbar .brand{display:block;float:left;padding:10px 20px 10px;margin-left:-20px;font-size:20px;font-weight:200;color:#777;text-shadow:0 1px 0 #fff}.navbar .brand:hover,.navbar .brand:focus{text-decoration:none}.navbar-text{margin-bottom:0;line-height:40px;color:#777}.navbar-link{color:#777}.navbar-link:hover,.navbar-link:focus{color:#333}.navbar .divider-vertical{height:40px;margin:0 9px;border-right:1px solid #fff;border-left:1px solid #f2f2f2}.navbar .btn,.navbar .btn-group{margin-top:5px}.navbar .btn-group .btn,.navbar .input-prepend .btn,.navbar .input-append .btn,.navbar .input-prepend .btn-group,.navbar .input-append .btn-group{margin-top:0}.navbar-form{margin-bottom:0;*zoom:1}.navbar-form:before,.navbar-form:after{display:table;line-height:0;content:""}.navbar-form:after{clear:both}.navbar-form input,.navbar-form select,.navbar-form .radio,.navbar-form .checkbox{margin-top:5px}.navbar-form input,.navbar-form select,.navbar-form .btn{display:inline-block;margin-bottom:0}.navbar-form input[type="image"],.navbar-form input[type="checkbox"],.navbar-form input[type="radio"]{margin-top:3px}.navbar-form .input-append,.navbar-form .input-prepend{margin-top:5px;white-space:nowrap}.navbar-form .input-append input,.navbar-form .input-prepend input{margin-top:0}.navbar-search{position:relative;float:left;margin-top:5px;margin-bottom:0}.navbar-search .search-query{padding:4px 14px;margin-bottom:0;font-family:"Helvetica Neue",Helvetica,Arial,sans-serif;font-size:13px;font-weight:normal;line-height:1;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.navbar-static-top{position:static;margin-bottom:0}.navbar-static-top .navbar-inner{-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.navbar-fixed-top,.navbar-fixed-bottom{position:fixed;right:0;left:0;z-index:1030;margin-bottom:0}.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{border-width:0 0 1px}.navbar-fixed-bottom .navbar-inner{border-width:1px 0 0}.navbar-fixed-top .navbar-inner,.navbar-fixed-bottom .navbar-inner{padding-right:0;padding-left:0;-webkit-border-radius:0;-moz-border-radius:0;border-radius:0}.navbar-static-top .container,.navbar-fixed-top .container,.navbar-fixed-bottom .container{width:940px}.navbar-fixed-top{top:0}.navbar-fixed-top .navbar-inner,.navbar-static-top .navbar-inner{-webkit-box-shadow:0 1px 10px rgba(0,0,0,0.1);-moz-box-shadow:0 1px 10px rgba(0,0,0,0.1);box-shadow:0 1px 10px rgba(0,0,0,0.1)}.navbar-fixed-bottom{bottom:0}.navbar-fixed-bottom .navbar-inner{-webkit-box-shadow:0 -1px 10px rgba(0,0,0,0.1);-moz-box-shadow:0 -1px 10px rgba(0,0,0,0.1);box-shadow:0 -1px 10px rgba(0,0,0,0.1)}.navbar .nav{position:relative;left:0;display:block;float:left;margin:0 10px 0 0}.navbar .nav.pull-right{float:right;margin-right:0}.navbar .nav>li{float:left}.navbar .nav>li>a{float:none;padding:10px 15px 10px;color:#777;text-decoration:none;text-shadow:0 1px 0 #fff}.navbar .nav .dropdown-toggle .caret{margin-top:8px}.navbar .nav>li>a:focus,.navbar .nav>li>a:hover{color:#333;text-decoration:none;background-color:transparent}.navbar .nav>.active>a,.navbar .nav>.active>a:hover,.navbar .nav>.active>a:focus{color:#555;text-decoration:none;background-color:#e5e5e5;-webkit-box-shadow:inset 0 3px 8px rgba(0,0,0,0.125);-moz-box-shadow:inset 0 3px 8px rgba(0,0,0,0.125);box-shadow:inset 0 3px 8px rgba(0,0,0,0.125)}.navbar .btn-navbar{display:none;float:right;padding:7px 10px;margin-right:5px;margin-left:5px;color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#ededed;*background-color:#e5e5e5;background-image:-moz-linear-gradient(top,#f2f2f2,#e5e5e5);background-image:-webkit-gradient(linear,0 0,0 100%,from(#f2f2f2),to(#e5e5e5));background-image:-webkit-linear-gradient(top,#f2f2f2,#e5e5e5);background-image:-o-linear-gradient(top,#f2f2f2,#e5e5e5);background-image:linear-gradient(to bottom,#f2f2f2,#e5e5e5);background-repeat:repeat-x;border-color:#e5e5e5 #e5e5e5 #bfbfbf;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff2f2f2',endColorstr='#ffe5e5e5',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false);-webkit-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.075);-moz-box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.075);box-shadow:inset 0 1px 0 rgba(255,255,255,0.1),0 1px 0 rgba(255,255,255,0.075)}.navbar .btn-navbar:hover,.navbar .btn-navbar:focus,.navbar .btn-navbar:active,.navbar .btn-navbar.active,.navbar .btn-navbar.disabled,.navbar .btn-navbar[disabled]{color:#fff;background-color:#e5e5e5;*background-color:#d9d9d9}.navbar .btn-navbar:active,.navbar .btn-navbar.active{background-color:#ccc \9}.navbar .btn-navbar .icon-bar{display:block;width:18px;height:2px;background-color:#f5f5f5;-webkit-border-radius:1px;-moz-border-radius:1px;border-radius:1px;-webkit-box-shadow:0 1px 0 rgba(0,0,0,0.25);-moz-box-shadow:0 1px 0 rgba(0,0,0,0.25);box-shadow:0 1px 0 rgba(0,0,0,0.25)}.btn-navbar .icon-bar+.icon-bar{margin-top:3px}.navbar .nav>li>.dropdown-menu:before{position:absolute;top:-7px;left:9px;display:inline-block;border-right:7px solid transparent;border-bottom:7px solid #ccc;border-left:7px solid transparent;border-bottom-color:rgba(0,0,0,0.2);content:''}.navbar .nav>li>.dropdown-menu:after{position:absolute;top:-6px;left:10px;display:inline-block;border-right:6px solid transparent;border-bottom:6px solid #fff;border-left:6px solid transparent;content:''}.navbar-fixed-bottom .nav>li>.dropdown-menu:before{top:auto;bottom:-7px;border-top:7px solid #ccc;border-bottom:0;border-top-color:rgba(0,0,0,0.2)}.navbar-fixed-bottom .nav>li>.dropdown-menu:after{top:auto;bottom:-6px;border-top:6px solid #fff;border-bottom:0}.navbar .nav li.dropdown>a:hover .caret,.navbar .nav li.dropdown>a:focus .caret{border-top-color:#333;border-bottom-color:#333}.navbar .nav li.dropdown.open>.dropdown-toggle,.navbar .nav li.dropdown.active>.dropdown-toggle,.navbar .nav li.dropdown.open.active>.dropdown-toggle{color:#555;background-color:#e5e5e5}.navbar .nav li.dropdown>.dropdown-toggle .caret{border-top-color:#777;border-bottom-color:#777}.navbar .nav li.dropdown.open>.dropdown-toggle .caret,.navbar .nav li.dropdown.active>.dropdown-toggle .caret,.navbar .nav li.dropdown.open.active>.dropdown-toggle .caret{border-top-color:#555;border-bottom-color:#555}.navbar .pull-right>li>.dropdown-menu,.navbar .nav>li>.dropdown-menu.pull-right{right:0;left:auto}.navbar .pull-right>li>.dropdown-menu:before,.navbar .nav>li>.dropdown-menu.pull-right:before{right:12px;left:auto}.navbar .pull-right>li>.dropdown-menu:after,.navbar .nav>li>.dropdown-menu.pull-right:after{right:13px;left:auto}.navbar .pull-right>li>.dropdown-menu .dropdown-menu,.navbar .nav>li>.dropdown-menu.pull-right .dropdown-menu{right:100%;left:auto;margin-right:-1px;margin-left:0;-webkit-border-radius:6px 0 6px 6px;-moz-border-radius:6px 0 6px 6px;border-radius:6px 0 6px 6px}.navbar-inverse .navbar-inner{background-color:#1b1b1b;background-image:-moz-linear-gradient(top,#222,#111);background-image:-webkit-gradient(linear,0 0,0 100%,from(#222),to(#111));background-image:-webkit-linear-gradient(top,#222,#111);background-image:-o-linear-gradient(top,#222,#111);background-image:linear-gradient(to bottom,#222,#111);background-repeat:repeat-x;border-color:#252525;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff222222',endColorstr='#ff111111',GradientType=0)}.navbar-inverse .brand,.navbar-inverse .nav>li>a{color:#999;text-shadow:0 -1px 0 rgba(0,0,0,0.25)}.navbar-inverse .brand:hover,.navbar-inverse .nav>li>a:hover,.navbar-inverse .brand:focus,.navbar-inverse .nav>li>a:focus{color:#fff}.navbar-inverse .brand{color:#999}.navbar-inverse .navbar-text{color:#999}.navbar-inverse .nav>li>a:focus,.navbar-inverse .nav>li>a:hover{color:#fff;background-color:transparent}.navbar-inverse .nav .active>a,.navbar-inverse .nav .active>a:hover,.navbar-inverse .nav .active>a:focus{color:#fff;background-color:#111}.navbar-inverse .navbar-link{color:#999}.navbar-inverse .navbar-link:hover,.navbar-inverse .navbar-link:focus{color:#fff}.navbar-inverse .divider-vertical{border-right-color:#222;border-left-color:#111}.navbar-inverse .nav li.dropdown.open>.dropdown-toggle,.navbar-inverse .nav li.dropdown.active>.dropdown-toggle,.navbar-inverse .nav li.dropdown.open.active>.dropdown-toggle{color:#fff;background-color:#111}.navbar-inverse .nav li.dropdown>a:hover .caret,.navbar-inverse .nav li.dropdown>a:focus .caret{border-top-color:#fff;border-bottom-color:#fff}.navbar-inverse .nav li.dropdown>.dropdown-toggle .caret{border-top-color:#999;border-bottom-color:#999}.navbar-inverse .nav li.dropdown.open>.dropdown-toggle .caret,.navbar-inverse .nav li.dropdown.active>.dropdown-toggle .caret,.navbar-inverse .nav li.dropdown.open.active>.dropdown-toggle .caret{border-top-color:#fff;border-bottom-color:#fff}.navbar-inverse .navbar-search .search-query{color:#fff;background-color:#515151;border-color:#111;-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1),0 1px 0 rgba(255,255,255,0.15);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1),0 1px 0 rgba(255,255,255,0.15);box-shadow:inset 0 1px 2px rgba(0,0,0,0.1),0 1px 0 rgba(255,255,255,0.15);-webkit-transition:none;-moz-transition:none;-o-transition:none;transition:none}.navbar-inverse .navbar-search .search-query:-moz-placeholder{color:#ccc}.navbar-inverse .navbar-search .search-query:-ms-input-placeholder{color:#ccc}.navbar-inverse .navbar-search .search-query::-webkit-input-placeholder{color:#ccc}.navbar-inverse .navbar-search .search-query:focus,.navbar-inverse .navbar-search .search-query.focused{padding:5px 15px;color:#333;text-shadow:0 1px 0 #fff;background-color:#fff;border:0;outline:0;-webkit-box-shadow:0 0 3px rgba(0,0,0,0.15);-moz-box-shadow:0 0 3px rgba(0,0,0,0.15);box-shadow:0 0 3px rgba(0,0,0,0.15)}.navbar-inverse .btn-navbar{color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#0e0e0e;*background-color:#040404;background-image:-moz-linear-gradient(top,#151515,#040404);background-image:-webkit-gradient(linear,0 0,0 100%,from(#151515),to(#040404));background-image:-webkit-linear-gradient(top,#151515,#040404);background-image:-o-linear-gradient(top,#151515,#040404);background-image:linear-gradient(to bottom,#151515,#040404);background-repeat:repeat-x;border-color:#040404 #040404 #000;border-color:rgba(0,0,0,0.1) rgba(0,0,0,0.1) rgba(0,0,0,0.25);filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff151515',endColorstr='#ff040404',GradientType=0);filter:progid:DXImageTransform.Microsoft.gradient(enabled=false)}.navbar-inverse .btn-navbar:hover,.navbar-inverse .btn-navbar:focus,.navbar-inverse .btn-navbar:active,.navbar-inverse .btn-navbar.active,.navbar-inverse .btn-navbar.disabled,.navbar-inverse .btn-navbar[disabled]{color:#fff;background-color:#040404;*background-color:#000}.navbar-inverse .btn-navbar:active,.navbar-inverse .btn-navbar.active{background-color:#000 \9}.breadcrumb{padding:8px 15px;margin:0 0 20px;list-style:none;background-color:#f5f5f5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.breadcrumb>li{display:inline-block;*display:inline;text-shadow:0 1px 0 #fff;*zoom:1}.breadcrumb>li>.divider{padding:0 5px;color:#ccc}.breadcrumb>.active{color:#999}.pagination{margin:20px 0}.pagination ul{display:inline-block;*display:inline;margin-bottom:0;margin-left:0;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;*zoom:1;-webkit-box-shadow:0 1px 2px rgba(0,0,0,0.05);-moz-box-shadow:0 1px 2px rgba(0,0,0,0.05);box-shadow:0 1px 2px rgba(0,0,0,0.05)}.pagination ul>li{display:inline}.pagination ul>li>a,.pagination ul>li>span{float:left;padding:4px 12px;line-height:20px;text-decoration:none;background-color:#fff;border:1px solid #ddd;border-left-width:0}.pagination ul>li>a:hover,.pagination ul>li>a:focus,.pagination ul>.active>a,.pagination ul>.active>span{background-color:#f5f5f5}.pagination ul>.active>a,.pagination ul>.active>span{color:#999;cursor:default}.pagination ul>.disabled>span,.pagination ul>.disabled>a,.pagination ul>.disabled>a:hover,.pagination ul>.disabled>a:focus{color:#999;cursor:default;background-color:transparent}.pagination ul>li:first-child>a,.pagination ul>li:first-child>span{border-left-width:1px;-webkit-border-bottom-left-radius:4px;border-bottom-left-radius:4px;-webkit-border-top-left-radius:4px;border-top-left-radius:4px;-moz-border-radius-bottomleft:4px;-moz-border-radius-topleft:4px}.pagination ul>li:last-child>a,.pagination ul>li:last-child>span{-webkit-border-top-right-radius:4px;border-top-right-radius:4px;-webkit-border-bottom-right-radius:4px;border-bottom-right-radius:4px;-moz-border-radius-topright:4px;-moz-border-radius-bottomright:4px}.pagination-centered{text-align:center}.pagination-right{text-align:right}.pagination-large ul>li>a,.pagination-large ul>li>span{padding:11px 19px;font-size:17.5px}.pagination-large ul>li:first-child>a,.pagination-large ul>li:first-child>span{-webkit-border-bottom-left-radius:6px;border-bottom-left-radius:6px;-webkit-border-top-left-radius:6px;border-top-left-radius:6px;-moz-border-radius-bottomleft:6px;-moz-border-radius-topleft:6px}.pagination-large ul>li:last-child>a,.pagination-large ul>li:last-child>span{-webkit-border-top-right-radius:6px;border-top-right-radius:6px;-webkit-border-bottom-right-radius:6px;border-bottom-right-radius:6px;-moz-border-radius-topright:6px;-moz-border-radius-bottomright:6px}.pagination-mini ul>li:first-child>a,.pagination-small ul>li:first-child>a,.pagination-mini ul>li:first-child>span,.pagination-small ul>li:first-child>span{-webkit-border-bottom-left-radius:3px;border-bottom-left-radius:3px;-webkit-border-top-left-radius:3px;border-top-left-radius:3px;-moz-border-radius-bottomleft:3px;-moz-border-radius-topleft:3px}.pagination-mini ul>li:last-child>a,.pagination-small ul>li:last-child>a,.pagination-mini ul>li:last-child>span,.pagination-small ul>li:last-child>span{-webkit-border-top-right-radius:3px;border-top-right-radius:3px;-webkit-border-bottom-right-radius:3px;border-bottom-right-radius:3px;-moz-border-radius-topright:3px;-moz-border-radius-bottomright:3px}.pagination-small ul>li>a,.pagination-small ul>li>span{padding:2px 10px;font-size:11.9px}.pagination-mini ul>li>a,.pagination-mini ul>li>span{padding:0 6px;font-size:10.5px}.pager{margin:20px 0;text-align:center;list-style:none;*zoom:1}.pager:before,.pager:after{display:table;line-height:0;content:""}.pager:after{clear:both}.pager li{display:inline}.pager li>a,.pager li>span{display:inline-block;padding:5px 14px;background-color:#fff;border:1px solid #ddd;-webkit-border-radius:15px;-moz-border-radius:15px;border-radius:15px}.pager li>a:hover,.pager li>a:focus{text-decoration:none;background-color:#f5f5f5}.pager .next>a,.pager .next>span{float:right}.pager .previous>a,.pager .previous>span{float:left}.pager .disabled>a,.pager .disabled>a:hover,.pager .disabled>a:focus,.pager .disabled>span{color:#999;cursor:default;background-color:#fff}.modal-backdrop{position:fixed;top:0;right:0;bottom:0;left:0;z-index:1040;background-color:#000}.modal-backdrop.fade{opacity:0}.modal-backdrop,.modal-backdrop.fade.in{opacity:.8;filter:alpha(opacity=80)}.modal{position:fixed;top:10%;left:50%;z-index:1050;width:560px;margin-left:-280px;background-color:#fff;border:1px solid #999;border:1px solid rgba(0,0,0,0.3);*border:1px solid #999;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;outline:0;-webkit-box-shadow:0 3px 7px rgba(0,0,0,0.3);-moz-box-shadow:0 3px 7px rgba(0,0,0,0.3);box-shadow:0 3px 7px rgba(0,0,0,0.3);-webkit-background-clip:padding-box;-moz-background-clip:padding-box;background-clip:padding-box}.modal.fade{top:-25%;-webkit-transition:opacity .3s linear,top .3s ease-out;-moz-transition:opacity .3s linear,top .3s ease-out;-o-transition:opacity .3s linear,top .3s ease-out;transition:opacity .3s linear,top .3s ease-out}.modal.fade.in{top:10%}.modal-header{padding:9px 15px;border-bottom:1px solid #eee}.modal-header .close{margin-top:2px}.modal-header h3{margin:0;line-height:30px}.modal-body{position:relative;max-height:400px;padding:15px;overflow-y:auto}.modal-form{margin-bottom:0}.modal-footer{padding:14px 15px 15px;margin-bottom:0;text-align:right;background-color:#f5f5f5;border-top:1px solid #ddd;-webkit-border-radius:0 0 6px 6px;-moz-border-radius:0 0 6px 6px;border-radius:0 0 6px 6px;*zoom:1;-webkit-box-shadow:inset 0 1px 0 #fff;-moz-box-shadow:inset 0 1px 0 #fff;box-shadow:inset 0 1px 0 #fff}.modal-footer:before,.modal-footer:after{display:table;line-height:0;content:""}.modal-footer:after{clear:both}.modal-footer .btn+.btn{margin-bottom:0;margin-left:5px}.modal-footer .btn-group .btn+.btn{margin-left:-1px}.modal-footer .btn-block+.btn-block{margin-left:0}.tooltip{position:absolute;z-index:1030;display:block;font-size:11px;line-height:1.4;opacity:0;filter:alpha(opacity=0);visibility:visible}.tooltip.in{opacity:.8;filter:alpha(opacity=80)}.tooltip.top{padding:5px 0;margin-top:-3px}.tooltip.right{padding:0 5px;margin-left:3px}.tooltip.bottom{padding:5px 0;margin-top:3px}.tooltip.left{padding:0 5px;margin-left:-3px}.tooltip-inner{max-width:200px;padding:8px;color:#fff;text-align:center;text-decoration:none;background-color:#000;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.tooltip-arrow{position:absolute;width:0;height:0;border-color:transparent;border-style:solid}.tooltip.top .tooltip-arrow{bottom:0;left:50%;margin-left:-5px;border-top-color:#000;border-width:5px 5px 0}.tooltip.right .tooltip-arrow{top:50%;left:0;margin-top:-5px;border-right-color:#000;border-width:5px 5px 5px 0}.tooltip.left .tooltip-arrow{top:50%;right:0;margin-top:-5px;border-left-color:#000;border-width:5px 0 5px 5px}.tooltip.bottom .tooltip-arrow{top:0;left:50%;margin-left:-5px;border-bottom-color:#000;border-width:0 5px 5px}.popover{position:absolute;top:0;left:0;z-index:1010;display:none;max-width:276px;padding:1px;text-align:left;white-space:normal;background-color:#fff;border:1px solid #ccc;border:1px solid rgba(0,0,0,0.2);-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px;-webkit-box-shadow:0 5px 10px rgba(0,0,0,0.2);-moz-box-shadow:0 5px 10px rgba(0,0,0,0.2);box-shadow:0 5px 10px rgba(0,0,0,0.2);-webkit-background-clip:padding-box;-moz-background-clip:padding;background-clip:padding-box}.popover.top{margin-top:-10px}.popover.right{margin-left:10px}.popover.bottom{margin-top:10px}.popover.left{margin-left:-10px}.popover-title{padding:8px 14px;margin:0;font-size:14px;font-weight:normal;line-height:18px;background-color:#f7f7f7;border-bottom:1px solid #ebebeb;-webkit-border-radius:5px 5px 0 0;-moz-border-radius:5px 5px 0 0;border-radius:5px 5px 0 0}.popover-title:empty{display:none}.popover-content{padding:9px 14px}.popover .arrow,.popover .arrow:after{position:absolute;display:block;width:0;height:0;border-color:transparent;border-style:solid}.popover .arrow{border-width:11px}.popover .arrow:after{border-width:10px;content:""}.popover.top .arrow{bottom:-11px;left:50%;margin-left:-11px;border-top-color:#999;border-top-color:rgba(0,0,0,0.25);border-bottom-width:0}.popover.top .arrow:after{bottom:1px;margin-left:-10px;border-top-color:#fff;border-bottom-width:0}.popover.right .arrow{top:50%;left:-11px;margin-top:-11px;border-right-color:#999;border-right-color:rgba(0,0,0,0.25);border-left-width:0}.popover.right .arrow:after{bottom:-10px;left:1px;border-right-color:#fff;border-left-width:0}.popover.bottom .arrow{top:-11px;left:50%;margin-left:-11px;border-bottom-color:#999;border-bottom-color:rgba(0,0,0,0.25);border-top-width:0}.popover.bottom .arrow:after{top:1px;margin-left:-10px;border-bottom-color:#fff;border-top-width:0}.popover.left .arrow{top:50%;right:-11px;margin-top:-11px;border-left-color:#999;border-left-color:rgba(0,0,0,0.25);border-right-width:0}.popover.left .arrow:after{right:1px;bottom:-10px;border-left-color:#fff;border-right-width:0}.thumbnails{margin-left:-20px;list-style:none;*zoom:1}.thumbnails:before,.thumbnails:after{display:table;line-height:0;content:""}.thumbnails:after{clear:both}.row-fluid .thumbnails{margin-left:0}.thumbnails>li{float:left;margin-bottom:20px;margin-left:20px}.thumbnail{display:block;padding:4px;line-height:20px;border:1px solid #ddd;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;-webkit-box-shadow:0 1px 3px rgba(0,0,0,0.055);-moz-box-shadow:0 1px 3px rgba(0,0,0,0.055);box-shadow:0 1px 3px rgba(0,0,0,0.055);-webkit-transition:all .2s ease-in-out;-moz-transition:all .2s ease-in-out;-o-transition:all .2s ease-in-out;transition:all .2s ease-in-out}a.thumbnail:hover,a.thumbnail:focus{border-color:#08c;-webkit-box-shadow:0 1px 4px rgba(0,105,214,0.25);-moz-box-shadow:0 1px 4px rgba(0,105,214,0.25);box-shadow:0 1px 4px rgba(0,105,214,0.25)}.thumbnail>img{display:block;max-width:100%;margin-right:auto;margin-left:auto}.thumbnail .caption{padding:9px;color:#555}.media,.media-body{overflow:hidden;*overflow:visible;zoom:1}.media,.media .media{margin-top:15px}.media:first-child{margin-top:0}.media-object{display:block}.media-heading{margin:0 0 5px}.media>.pull-left{margin-right:10px}.media>.pull-right{margin-left:10px}.media-list{margin-left:0;list-style:none}.label,.badge{display:inline-block;padding:2px 4px;font-size:11.844px;font-weight:bold;line-height:14px;color:#fff;text-shadow:0 -1px 0 rgba(0,0,0,0.25);white-space:nowrap;vertical-align:baseline;background-color:#999}.label{-webkit-border-radius:3px;-moz-border-radius:3px;border-radius:3px}.badge{padding-right:9px;padding-left:9px;-webkit-border-radius:9px;-moz-border-radius:9px;border-radius:9px}.label:empty,.badge:empty{display:none}a.label:hover,a.label:focus,a.badge:hover,a.badge:focus{color:#fff;text-decoration:none;cursor:pointer}.label-important,.badge-important{background-color:#b94a48}.label-important[href],.badge-important[href]{background-color:#953b39}.label-warning,.badge-warning{background-color:#f89406}.label-warning[href],.badge-warning[href]{background-color:#c67605}.label-success,.badge-success{background-color:#468847}.label-success[href],.badge-success[href]{background-color:#356635}.label-info,.badge-info{background-color:#3a87ad}.label-info[href],.badge-info[href]{background-color:#2d6987}.label-inverse,.badge-inverse{background-color:#333}.label-inverse[href],.badge-inverse[href]{background-color:#1a1a1a}.btn .label,.btn .badge{position:relative;top:-1px}.btn-mini .label,.btn-mini .badge{top:0}@-webkit-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-moz-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-ms-keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}@-o-keyframes progress-bar-stripes{from{background-position:0 0}to{background-position:40px 0}}@keyframes progress-bar-stripes{from{background-position:40px 0}to{background-position:0 0}}.progress{height:20px;margin-bottom:20px;overflow:hidden;background-color:#f7f7f7;background-image:-moz-linear-gradient(top,#f5f5f5,#f9f9f9);background-image:-webkit-gradient(linear,0 0,0 100%,from(#f5f5f5),to(#f9f9f9));background-image:-webkit-linear-gradient(top,#f5f5f5,#f9f9f9);background-image:-o-linear-gradient(top,#f5f5f5,#f9f9f9);background-image:linear-gradient(to bottom,#f5f5f5,#f9f9f9);background-repeat:repeat-x;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fff5f5f5',endColorstr='#fff9f9f9',GradientType=0);-webkit-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1);-moz-box-shadow:inset 0 1px 2px rgba(0,0,0,0.1);box-shadow:inset 0 1px 2px rgba(0,0,0,0.1)}.progress .bar{float:left;width:0;height:100%;font-size:12px;color:#fff;text-align:center;text-shadow:0 -1px 0 rgba(0,0,0,0.25);background-color:#0e90d2;background-image:-moz-linear-gradient(top,#149bdf,#0480be);background-image:-webkit-gradient(linear,0 0,0 100%,from(#149bdf),to(#0480be));background-image:-webkit-linear-gradient(top,#149bdf,#0480be);background-image:-o-linear-gradient(top,#149bdf,#0480be);background-image:linear-gradient(to bottom,#149bdf,#0480be);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff149bdf',endColorstr='#ff0480be',GradientType=0);-webkit-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);-moz-box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);box-shadow:inset 0 -1px 0 rgba(0,0,0,0.15);-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;-webkit-transition:width .6s ease;-moz-transition:width .6s ease;-o-transition:width .6s ease;transition:width .6s ease}.progress .bar+.bar{-webkit-box-shadow:inset 1px 0 0 rgba(0,0,0,0.15),inset 0 -1px 0 rgba(0,0,0,0.15);-moz-box-shadow:inset 1px 0 0 rgba(0,0,0,0.15),inset 0 -1px 0 rgba(0,0,0,0.15);box-shadow:inset 1px 0 0 rgba(0,0,0,0.15),inset 0 -1px 0 rgba(0,0,0,0.15)}.progress-striped .bar{background-color:#149bdf;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);-webkit-background-size:40px 40px;-moz-background-size:40px 40px;-o-background-size:40px 40px;background-size:40px 40px}.progress.active .bar{-webkit-animation:progress-bar-stripes 2s linear infinite;-moz-animation:progress-bar-stripes 2s linear infinite;-ms-animation:progress-bar-stripes 2s linear infinite;-o-animation:progress-bar-stripes 2s linear infinite;animation:progress-bar-stripes 2s linear infinite}.progress-danger .bar,.progress .bar-danger{background-color:#dd514c;background-image:-moz-linear-gradient(top,#ee5f5b,#c43c35);background-image:-webkit-gradient(linear,0 0,0 100%,from(#ee5f5b),to(#c43c35));background-image:-webkit-linear-gradient(top,#ee5f5b,#c43c35);background-image:-o-linear-gradient(top,#ee5f5b,#c43c35);background-image:linear-gradient(to bottom,#ee5f5b,#c43c35);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ffee5f5b',endColorstr='#ffc43c35',GradientType=0)}.progress-danger.progress-striped .bar,.progress-striped .bar-danger{background-color:#ee5f5b;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.progress-success .bar,.progress .bar-success{background-color:#5eb95e;background-image:-moz-linear-gradient(top,#62c462,#57a957);background-image:-webkit-gradient(linear,0 0,0 100%,from(#62c462),to(#57a957));background-image:-webkit-linear-gradient(top,#62c462,#57a957);background-image:-o-linear-gradient(top,#62c462,#57a957);background-image:linear-gradient(to bottom,#62c462,#57a957);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff62c462',endColorstr='#ff57a957',GradientType=0)}.progress-success.progress-striped .bar,.progress-striped .bar-success{background-color:#62c462;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.progress-info .bar,.progress .bar-info{background-color:#4bb1cf;background-image:-moz-linear-gradient(top,#5bc0de,#339bb9);background-image:-webkit-gradient(linear,0 0,0 100%,from(#5bc0de),to(#339bb9));background-image:-webkit-linear-gradient(top,#5bc0de,#339bb9);background-image:-o-linear-gradient(top,#5bc0de,#339bb9);background-image:linear-gradient(to bottom,#5bc0de,#339bb9);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#ff5bc0de',endColorstr='#ff339bb9',GradientType=0)}.progress-info.progress-striped .bar,.progress-striped .bar-info{background-color:#5bc0de;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.progress-warning .bar,.progress .bar-warning{background-color:#faa732;background-image:-moz-linear-gradient(top,#fbb450,#f89406);background-image:-webkit-gradient(linear,0 0,0 100%,from(#fbb450),to(#f89406));background-image:-webkit-linear-gradient(top,#fbb450,#f89406);background-image:-o-linear-gradient(top,#fbb450,#f89406);background-image:linear-gradient(to bottom,#fbb450,#f89406);background-repeat:repeat-x;filter:progid:DXImageTransform.Microsoft.gradient(startColorstr='#fffbb450',endColorstr='#fff89406',GradientType=0)}.progress-warning.progress-striped .bar,.progress-striped .bar-warning{background-color:#fbb450;background-image:-webkit-gradient(linear,0 100%,100% 0,color-stop(0.25,rgba(255,255,255,0.15)),color-stop(0.25,transparent),color-stop(0.5,transparent),color-stop(0.5,rgba(255,255,255,0.15)),color-stop(0.75,rgba(255,255,255,0.15)),color-stop(0.75,transparent),to(transparent));background-image:-webkit-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-moz-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:-o-linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent);background-image:linear-gradient(45deg,rgba(255,255,255,0.15) 25%,transparent 25%,transparent 50%,rgba(255,255,255,0.15) 50%,rgba(255,255,255,0.15) 75%,transparent 75%,transparent)}.accordion{margin-bottom:20px}.accordion-group{margin-bottom:2px;border:1px solid #e5e5e5;-webkit-border-radius:4px;-moz-border-radius:4px;border-radius:4px}.accordion-heading{border-bottom:0}.accordion-heading .accordion-toggle{display:block;padding:8px 15px}.accordion-toggle{cursor:pointer}.accordion-inner{padding:9px 15px;border-top:1px solid #e5e5e5}.carousel{position:relative;margin-bottom:20px;line-height:1}.carousel-inner{position:relative;width:100%;overflow:hidden}.carousel-inner>.item{position:relative;display:none;-webkit-transition:.6s ease-in-out left;-moz-transition:.6s ease-in-out left;-o-transition:.6s ease-in-out left;transition:.6s ease-in-out left}.carousel-inner>.item>img,.carousel-inner>.item>a>img{display:block;line-height:1}.carousel-inner>.active,.carousel-inner>.next,.carousel-inner>.prev{display:block}.carousel-inner>.active{left:0}.carousel-inner>.next,.carousel-inner>.prev{position:absolute;top:0;width:100%}.carousel-inner>.next{left:100%}.carousel-inner>.prev{left:-100%}.carousel-inner>.next.left,.carousel-inner>.prev.right{left:0}.carousel-inner>.active.left{left:-100%}.carousel-inner>.active.right{left:100%}.carousel-control{position:absolute;top:40%;left:15px;width:40px;height:40px;margin-top:-20px;font-size:60px;font-weight:100;line-height:30px;color:#fff;text-align:center;background:#222;border:3px solid #fff;-webkit-border-radius:23px;-moz-border-radius:23px;border-radius:23px;opacity:.5;filter:alpha(opacity=50)}.carousel-control.right{right:15px;left:auto}.carousel-control:hover,.carousel-control:focus{color:#fff;text-decoration:none;opacity:.9;filter:alpha(opacity=90)}.carousel-indicators{position:absolute;top:15px;right:15px;z-index:5;margin:0;list-style:none}.carousel-indicators li{display:block;float:left;width:10px;height:10px;margin-left:5px;text-indent:-999px;background-color:#ccc;background-color:rgba(255,255,255,0.25);border-radius:5px}.carousel-indicators .active{background-color:#fff}.carousel-caption{position:absolute;right:0;bottom:0;left:0;padding:15px;background:#333;background:rgba(0,0,0,0.75)}.carousel-caption h4,.carousel-caption p{line-height:20px;color:#fff}.carousel-caption h4{margin:0 0 5px}.carousel-caption p{margin-bottom:0}.hero-unit{padding:60px;margin-bottom:30px;font-size:18px;font-weight:200;line-height:30px;color:inherit;background-color:#eee;-webkit-border-radius:6px;-moz-border-radius:6px;border-radius:6px}.hero-unit h1{margin-bottom:0;font-size:60px;line-height:1;letter-spacing:-1px;color:inherit}.hero-unit li{line-height:30px}.pull-right{float:right}.pull-left{float:left}.hide{display:none}.show{display:block}.invisible{visibility:hidden}.affix{position:fixed}
diff --git a/website/source/stylesheets/main.css.scss b/website/source/stylesheets/main.css.scss
deleted file mode 100644
index 29826a751..000000000
--- a/website/source/stylesheets/main.css.scss
+++ /dev/null
@@ -1,7 +0,0 @@
-@import "helpers";
-@import "reset";
-@import "styles";
-@import "nav";
-@import "footer";
-@import "components";
-@import "sidebar";
diff --git a/website/source/stylesheets/prettify.css b/website/source/stylesheets/prettify.css
deleted file mode 100644
index 49af933bf..000000000
--- a/website/source/stylesheets/prettify.css
+++ /dev/null
@@ -1,160 +0,0 @@
-/* Hemisu Dark */
-/* Original theme - http://noahfrederick.com/vim-color-scheme-hemisu/ */
-/* Pretty printing styles. Used with prettify.js. */
-/* SPAN elements with the classes below are added by prettyprint. */
-/* plain text */
-.pln {
-    color: #eeeeee;
-}
-
-@media screen {
-    /* string content */
-    .str {
-        color: #b1d631;
-    }
-
-    /* a keyword */
-    .kwd {
-        color: #b1d631;
-    }
-
-    /* a comment */
-    .com {
-        color: #777777;
-    }
-
-    /* a type name */
-    .typ {
-        color: #bbffaa;
-    }
-
-    /* a literal value */
-    .lit {
-        color: #9fd3e6;
-    }
-
-    /* punctuation */
-    .pun {
-        color: #eeeeee;
-    }
-
-    /* lisp open bracket */
-    .opn {
-        color: #eeeeee;
-    }
-
-    /* lisp close bracket */
-    .clo {
-        color: #eeeeee;
-    }
-
-    /* a markup tag name */
-    .tag {
-        color: #eeeeee;
-    }
-
-    /* a markup attribute name */
-    .atn {
-        color: #b1d631;
-    }
-
-    /* a markup attribute value */
-    .atv {
-        color: #bbffaa;
-    }
-
-    /* a declaration */
-    .dec {
-        color: #eeeeee;
-    }
-
-    /* a variable name */
-    .var {
-        color: #eeeeee;
-    }
-
-    /* a function name */
-    .fun {
-        color: #9fd3e6;
-    }
-}
-/* Use higher contrast and text-weight for printable form. */
-@media print, projection {
-    .str {
-        color: #006600;
-    }
-
-    .kwd {
-        color: #006;
-        font-weight: bold;
-    }
-
-    .com {
-        color: #600;
-        font-style: italic;
-    }
-
-    .typ {
-        color: #404;
-        font-weight: bold;
-    }
-
-    .lit {
-        color: #004444;
-    }
-
-    .pun, .opn, .clo {
-        color: #444400;
-    }
-
-    .tag {
-        color: #006;
-        font-weight: bold;
-    }
-
-    .atn {
-        color: #440044;
-    }
-
-    .atv {
-        color: #006600;
-    }
-}
-/* Style */
-pre.prettyprint {
-    background: black;
-    font-family: Menlo, "Bitstream Vera Sans Mono", "DejaVu Sans Mono", Monaco, Consolas, monospace;
-    font-size: 12px;
-    line-height: 1.5;
-    border: 1px solid #cccccc;
-    padding: 10px;
-}
-
-/* Specify class=linenums on a pre to get line numbering */
-ol.linenums {
-    margin-top: 0;
-    margin-bottom: 0;
-}
-
-/* IE indents via margin-left */
-li.L0,
-li.L1,
-li.L2,
-li.L3,
-li.L4,
-li.L5,
-li.L6,
-li.L7,
-li.L8,
-li.L9 {
-    /* */
-}
-
-/* Alternate shading for lines */
-li.L1,
-li.L3,
-li.L5,
-li.L7,
-li.L9 {
-    /* */
-}