diff --git a/config/default.rb b/config/default.rb
index e4002fb0369..cddc0fe6574 100644
--- a/config/default.rb
+++ b/config/default.rb
@@ -24,7 +24,7 @@
 
   # Share the root folder. This can then be overridden by
   # other Vagrantfiles, if they wish.
-  config.vm.share_folder("v-root", "/vagrant", ".")
+  config.vm.synced_folder(".", "/vagrant", :id => "vagrant-root")
 
   config.nfs.map_uid = :auto
   config.nfs.map_gid = :auto
diff --git a/plugins/kernel_v1/config/vm.rb b/plugins/kernel_v1/config/vm.rb
index 6a0a7b3bd85..e1cb36d0dde 100644
--- a/plugins/kernel_v1/config/vm.rb
+++ b/plugins/kernel_v1/config/vm.rb
@@ -121,11 +121,12 @@ def upgrade(new)
 
         # Shared folders
         self.shared_folders.each do |name, sf|
-          options = sf.dup
-          guestpath = options.delete(:guestpath)
-          hostpath = options.delete(:hostpath)
+          options      = sf.dup
+          options[:id] = name
+          guestpath    = options.delete(:guestpath)
+          hostpath     = options.delete(:hostpath)
 
-          new.vm.share_folder(name, guestpath, hostpath, options)
+          new.vm.synced_folder(hostpath, guestpath, options)
         end
 
         # Defined sub-VMs
diff --git a/plugins/kernel_v2/config/vm.rb b/plugins/kernel_v2/config/vm.rb
index 0ce31b54c0f..0a564d1ca39 100644
--- a/plugins/kernel_v2/config/vm.rb
+++ b/plugins/kernel_v2/config/vm.rb
@@ -21,7 +21,7 @@ class VMConfig < Vagrant.plugin("2", :config)
       attr_accessor :host_name
       attr_accessor :usable_port_range
       attr_reader :forwarded_ports
-      attr_reader :shared_folders
+      attr_reader :synced_folders
       attr_reader :networks
       attr_reader :providers
       attr_reader :provisioners
@@ -30,7 +30,7 @@ def initialize
         @forwarded_ports              = []
         @graceful_halt_retry_count    = UNSET_VALUE
         @graceful_halt_retry_interval = UNSET_VALUE
-        @shared_folders               = {}
+        @synced_folders               = {}
         @networks                     = []
         @provisioners                 = []
 
@@ -44,23 +44,31 @@ def initialize
       def merge(other)
         result = super
         result.instance_variable_set(:@forwarded_ports, @forwarded_ports + other.forwarded_ports)
-        result.instance_variable_set(:@shared_folders, @shared_folders.merge(other.shared_folders))
+        result.instance_variable_set(:@synced_folders, @synced_folders.merge(other.synced_folders))
         result.instance_variable_set(:@networks, @networks + other.networks)
         result.instance_variable_set(:@provisioners, @provisioners + other.provisioners)
         result
       end
 
-      def share_folder(name, guestpath, hostpath, opts=nil)
-        @shared_folders[name] = {
-          :guestpath => guestpath.to_s,
-          :hostpath => hostpath.to_s,
-          :create => false,
-          :owner => nil,
-          :group => nil,
-          :nfs   => false,
-          :transient => false,
-          :extra => nil
-        }.merge(opts || {})
+      # Defines a synced folder pair. This pair of folders will be synced
+      # to/from the machine. Note that if the machine you're using doesn't
+      # support multi-directional syncing (perhaps an rsync backed synced
+      # folder) then the host is always synced to the guest but guest data
+      # may not be synced back to the host.
+      #
+      # @param [String] hostpath Path to the host folder to share. If this
+      #   is a relative path, it is relative to the location of the
+      #   Vagrantfile.
+      # @param [String] guestpath Path on the guest to mount the shared
+      #   folder.
+      # @param [Hash] options Additional options.
+      def synced_folder(hostpath, guestpath, options=nil)
+        options ||= {}
+        options[:id] ||= guestpah
+        options[:guestpath] = guestpath
+        options[:hostpath]  = hostpath
+
+        @synced_folders[options[:id]] = options
       end
 
       # Define a way to access the machine via a network. This exposes a
@@ -133,19 +141,18 @@ def validate(machine)
         errors << I18n.t("vagrant.config.vm.box_not_found", :name => box) if \
           box && !box_url && !machine.box
 
-        shared_folders.each do |name, options|
+        @synced_folders.each do |id, options|
           hostpath = Pathname.new(options[:hostpath]).expand_path(machine.env.root_path)
 
           if !hostpath.directory? && !options[:create]
             errors << I18n.t("vagrant.config.vm.shared_folder_hostpath_missing",
-                       :name => name,
-                       :path => options[:hostpath])
+                             :path => options[:hostpath])
           end
 
           if options[:nfs] && (options[:owner] || options[:group])
             # Owner/group don't work with NFS
             errors << I18n.t("vagrant.config.vm.shared_folder_nfs_owner_group",
-                              :name => name)
+                             :path => options[:hostpath])
           end
         end
 
diff --git a/plugins/providers/virtualbox/action/nfs.rb b/plugins/providers/virtualbox/action/nfs.rb
index 90eaae32059..1ca6ef9f725 100644
--- a/plugins/providers/virtualbox/action/nfs.rb
+++ b/plugins/providers/virtualbox/action/nfs.rb
@@ -42,7 +42,7 @@ def folders
         def extract_folders
           # Load the NFS enabled shared folders
           @folders = {}
-          @env[:machine].config.vm.shared_folders.each do |key, opts|
+          @env[:machine].config.vm.synced_folders.each do |id, opts|
             if opts[:nfs]
               # Duplicate the options, set the hostpath, and set disabled on the original
               # options so the ShareFolders middleware doesn't try to mount it.
@@ -65,7 +65,7 @@ def extract_folders
               folder[:hostpath] = hostpath.to_s
 
               # Assign the folder to our instance variable for later use
-              @folders[key] = folder
+              @folders[id] = folder
 
               # Disable the folder so that regular shared folders don't try to
               # mount it.
@@ -78,7 +78,7 @@ def extract_folders
         # options on the NFS folders.
         def prepare_folders
           @folders = @folders.inject({}) do |acc, data|
-            key, opts = data
+            id, opts = data
             opts[:map_uid] = prepare_permission(:uid, opts)
             opts[:map_gid] = prepare_permission(:gid, opts)
             opts[:nfs_version] ||= 3
@@ -89,7 +89,7 @@ def prepare_folders
             # the same host path will hash to the same fsid.
             opts[:uuid]    = Digest::MD5.hexdigest(opts[:hostpath])
 
-            acc[key] = opts
+            acc[id] = opts
             acc
           end
         end
@@ -166,8 +166,8 @@ def guest_ip
 
         # Checks if there are any NFS enabled shared folders.
         def nfs_enabled?
-          @env[:machine].config.vm.shared_folders.each do |key, opts|
-            return true if opts[:nfs]
+          @env[:machine].config.vm.synced_folders.each do |id, options|
+            return true if options[:nfs]
           end
 
           false
diff --git a/plugins/providers/virtualbox/action/share_folders.rb b/plugins/providers/virtualbox/action/share_folders.rb
index a68beb926e7..1a41ea9d7a0 100644
--- a/plugins/providers/virtualbox/action/share_folders.rb
+++ b/plugins/providers/virtualbox/action/share_folders.rb
@@ -25,22 +25,20 @@ def call(env)
         # This method returns an actual list of VirtualBox shared
         # folders to create and their proper path.
         def shared_folders
-          @env[:machine].config.vm.shared_folders.inject({}) do |acc, data|
-            key, value = data
+          {}.tap do |result|
+            @env[:machine].config.vm.synced_folders.each do |id, data|
+              next if data[:disabled]
 
-            next acc if value[:disabled]
-
-            # This to prevent overwriting the actual shared folders data
-            value = value.dup
-            acc[key] = value
-            acc
+              # This to prevent overwriting the actual shared folders data
+              result[id] = data.dup
+            end
           end
         end
 
         # Prepares the shared folders by verifying they exist and creating them
         # if they don't.
         def prepare_folders
-          shared_folders.each do |name, options|
+          shared_folders.each do |id, options|
             hostpath = Pathname.new(options[:hostpath]).expand_path(@env[:root_path])
 
             if !hostpath.directory? && options[:create]
@@ -61,9 +59,9 @@ def create_metadata
           @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.creating")
 
           folders = []
-          shared_folders.each do |name, data|
+          shared_folders.each do |id, data|
             folders << {
-              :name => name,
+              :name => id,
               :hostpath => File.expand_path(data[:hostpath], @env[:root_path]),
               :transient => data[:transient]
             }
@@ -76,7 +74,7 @@ def mount_shared_folders
           @env[:ui].info I18n.t("vagrant.actions.vm.share_folders.mounting")
 
           # short guestpaths first, so we don't step on ourselves
-          folders = shared_folders.sort_by do |name, data|
+          folders = shared_folders.sort_by do |id, data|
             if data[:guestpath]
               data[:guestpath].length
             else
@@ -86,11 +84,10 @@ def mount_shared_folders
           end
 
           # Go through each folder and mount
-          folders.each do |name, data|
+          folders.each do |id, data|
             if data[:guestpath]
               # Guest path specified, so mount the folder to specified point
               @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.mounting_entry",
-                                    :name => name,
                                     :guest_path => data[:guestpath]))
 
               # Dup the data so we can pass it to the guest API
@@ -101,11 +98,11 @@ def mount_shared_folders
               data[:group] ||= @env[:machine].config.ssh.username
 
               # Mount the actual folder
-              @env[:machine].guest.mount_shared_folder(name, data[:guestpath], data)
+              @env[:machine].guest.mount_shared_folder(id, data[:guestpath], data)
             else
               # If no guest path is specified, then automounting is disabled
               @env[:ui].info(I18n.t("vagrant.actions.vm.share_folders.nomount_entry",
-                                    :name => name))
+                                    :host_path => data[:hostpath]))
             end
           end
         end
diff --git a/plugins/provisioners/chef/provisioner/chef_solo.rb b/plugins/provisioners/chef/provisioner/chef_solo.rb
index adcadb4a116..ccb9a52d2f8 100644
--- a/plugins/provisioners/chef/provisioner/chef_solo.rb
+++ b/plugins/provisioners/chef/provisioner/chef_solo.rb
@@ -111,9 +111,10 @@ def expanded_folders(paths, appended_folder=nil)
         def share_folders(root_config, prefix, folders)
           folders.each do |type, local_path, remote_path|
             if type == :host
-              root_config.vm.share_folder(
-                "v-#{prefix}-#{self.class.get_and_update_counter(:shared_folder)}",
-                remote_path, local_path, :nfs => @config.nfs)
+              root_config.vm.synced_folder(
+                local_path, remote_path,
+                :id =>  "v-#{prefix}-#{self.class.get_and_update_counter(:shared_folder)}",
+                :nfs => @config.nfs)
             end
           end
         end
diff --git a/plugins/provisioners/puppet/provisioner/puppet.rb b/plugins/provisioners/puppet/provisioner/puppet.rb
index d105a854b79..11a794a6b33 100644
--- a/plugins/provisioners/puppet/provisioner/puppet.rb
+++ b/plugins/provisioners/puppet/provisioner/puppet.rb
@@ -28,15 +28,15 @@ def configure(root_config)
           end
 
           # Share the manifests directory with the guest
-          root_config.vm.share_folder(
-            "manifests", manifests_guest_path, @expanded_manifests_path)
+          root_config.vm.synced_folder(
+            @expanded_manifests_path, manifests_guest_path)
 
           # Share the module paths
           count = 0
           @module_paths.each do |from, to|
             # Sorry for the cryptic key here, but VirtualBox has a strange limit on
             # maximum size for it and its something small (around 10)
-            root_config.vm.share_folder("v-pp-m#{count}", to, from)
+            root_config.vm.synced_folder(from, to)
             count += 1
           end
         end
diff --git a/templates/locales/en.yml b/templates/locales/en.yml
index 40c98bccc25..ebe859f00af 100644
--- a/templates/locales/en.yml
+++ b/templates/locales/en.yml
@@ -351,9 +351,11 @@ en:
         network_ip_ends_one: |-
           The host only network IP '%{ip}' must not end in a 1, as this
           is reserved for the host machine.
-        shared_folder_hostpath_missing: "Shared folder host path for '%{name}' doesn't exist: %{path}"
+        shared_folder_hostpath_missing: |-
+          The host path of the shared folder is missing: %{path}
         shared_folder_nfs_owner_group: |-
-          Shared folder '%{name}': NFS does not support the owner/group settings.
+          Shared folder that have NFS enabled do no support owner/group
+          attributes. Host path: %{path}
         provisioner_not_found: "The provisioner '%{shortcut}' doesn't exist."
         provisioner_invalid_class: |-
           The provisioner '%{shortcut}' must inherit from
@@ -659,8 +661,8 @@ en:
         share_folders:
           creating: Creating shared folders metadata...
           mounting: Mounting shared folders...
-          mounting_entry: "-- %{name}: %{guest_path}"
-          nomount_entry: "-- %{name}: Automounting disabled."
+          mounting_entry: "-- %{guest_path}"
+          nomount_entry: "-- Automounting disabled: %{host_path}"
         suspend:
           suspending: Saving VM state and suspending execution...