diff --git a/crates/wasmparser/src/validator/component.rs b/crates/wasmparser/src/validator/component.rs
index 1e9441035b..9a010ca3ff 100644
--- a/crates/wasmparser/src/validator/component.rs
+++ b/crates/wasmparser/src/validator/component.rs
@@ -4538,6 +4538,7 @@ impl ComponentNameContext {
                 | ComponentNameKind::Method(_)
                 | ComponentNameKind::Static(_)
                 | ComponentNameKind::Constructor(_)
+                | ComponentNameKind::Implements(_)
                 | ComponentNameKind::Interface(_) => {}
 
                 ComponentNameKind::Hash(_)
@@ -4608,6 +4609,17 @@ impl ComponentNameContext {
             | ComponentNameKind::Dependency(_)
             | ComponentNameKind::Hash(_) => {}
 
+            // `[implements=<I>]L` may only appear on instance imports/exports.
+            ComponentNameKind::Implements(imp) => match ty {
+                ComponentEntityType::Instance(_) => {}
+                _ => bail!(
+                    offset,
+                    "`implements` name `[implements=<{}>]{}` can only be used with instance types",
+                    imp.interface(),
+                    imp.label(),
+                ),
+            },
+
             // Constructors must return `(own $resource)` or
             // `(result (own $Tresource))` and the `$resource` must be named
             // within this context to match `rname`.
diff --git a/crates/wasmparser/src/validator/names.rs b/crates/wasmparser/src/validator/names.rs
index 5ec899634e..d8594557a0 100644
--- a/crates/wasmparser/src/validator/names.rs
+++ b/crates/wasmparser/src/validator/names.rs
@@ -242,6 +242,7 @@ impl From<KebabString> for String {
 /// * a plain method name : `[method]a-b.c-d`
 /// * a plain static method name : `[static]a-b.c-d`
 /// * a plain constructor: `[constructor]a-b`
+/// * an implements name: `[implements=<a:b/c>]label`
 /// * an interface name: `wasi:cli/reactor@0.1.0`
 /// * a dependency name: `locked-dep=foo:bar/baz`
 /// * a URL name: `url=https://..`
@@ -252,6 +253,10 @@ impl From<KebabString> for String {
 /// Note that this type the `[method]...` and `[static]...` variants are
 /// considered equal and hash to the same value. This enables disallowing
 /// clashes between the two where method name overlap cannot happen.
+///
+/// Similarly, `[implements=<I>]L` is considered equal to a bare label `L`
+/// (they conflict on the same label). Two `[implements=<...>]` names with
+/// the same label also conflict, regardless of the interface name.
 #[derive(Clone)]
 pub struct ComponentName {
     raw: String,
@@ -264,6 +269,7 @@ enum ParsedComponentNameKind {
     Constructor,
     Method,
     Static,
+    Implements,
     Interface,
     Dependency,
     Url,
@@ -283,6 +289,9 @@ pub enum ComponentNameKind<'a> {
     /// `[static]a-b.c-d`
     #[allow(missing_docs)]
     Static(ResourceFunc<'a>),
+    /// A plain-named instance that implements a named interface, e.g.
+    /// `[implements=<a:b/c>]label`.
+    Implements(ImplementsName<'a>),
     /// `wasi:http/types@2.0`
     #[allow(missing_docs)]
     Interface(InterfaceName<'a>),
@@ -300,6 +309,7 @@ pub enum ComponentNameKind<'a> {
 const CONSTRUCTOR: &str = "[constructor]";
 const METHOD: &str = "[method]";
 const STATIC: &str = "[static]";
+const IMPLEMENTS_PREFIX: &str = "[implements=<";
 
 impl ComponentName {
     /// Attempts to parse `name` as a valid component name, returning `Err` if
@@ -338,6 +348,7 @@ impl ComponentName {
             PK::Constructor => Constructor(KebabStr::new_unchecked(&self.raw[CONSTRUCTOR.len()..])),
             PK::Method => Method(ResourceFunc(&self.raw[METHOD.len()..])),
             PK::Static => Static(ResourceFunc(&self.raw[STATIC.len()..])),
+            PK::Implements => Implements(ImplementsName(&self.raw[IMPLEMENTS_PREFIX.len()..])),
             PK::Interface => Interface(InterfaceName(&self.raw)),
             PK::Dependency => Dependency(DependencyName(&self.raw)),
             PK::Url => Url(UrlName(&self.raw)),
@@ -379,7 +390,7 @@ impl Ord for ComponentName {
 
 impl PartialOrd for ComponentName {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.kind.partial_cmp(&other.kind)
+        Some(self.kind().cmp(&other.kind()))
     }
 }
 
@@ -397,9 +408,13 @@ impl fmt::Debug for ComponentName {
 
 impl ComponentNameKind<'_> {
     /// Returns the [`ParsedComponentNameKind`] of the [`ComponentNameKind`].
+    ///
+    /// Note that `Implements` maps to `Label` because they share the same
+    /// uniqueness namespace (an `[implements=<I>]L` name conflicts with a
+    /// bare label `L`).
     fn kind(&self) -> ParsedComponentNameKind {
         match self {
-            Self::Label(_) => ParsedComponentNameKind::Label,
+            Self::Label(_) | Self::Implements(_) => ParsedComponentNameKind::Label,
             Self::Constructor(_) => ParsedComponentNameKind::Constructor,
             Self::Method(_) => ParsedComponentNameKind::Method,
             Self::Static(_) => ParsedComponentNameKind::Static,
@@ -428,12 +443,29 @@ impl Ord for ComponentNameKind<'_> {
                 Ordering::Equal
             }
 
+            // `[implements=<I>]L` compares by label only, and is equivalent
+            // to a bare label `L`.
+            (Implements(lhs), Implements(rhs)) => lhs.label().cmp(rhs.label()),
+            (Label(lhs), Implements(rhs)) => (*lhs).cmp(rhs.label()),
+            (Implements(lhs), Label(rhs)) => lhs.label().cmp(*rhs),
+
+            // `[implements=<I>]l` is equivalent to `[method]l.l` / `[static]l.l`
+            // when resource == method (the `l.l` edge case that also equals
+            // bare label `l`).
+            (Implements(imp), Method(method) | Static(method))
+            | (Method(method) | Static(method), Implements(imp))
+                if imp.label() == method.resource() && imp.label() == method.method() =>
+            {
+                Ordering::Equal
+            }
+
             (Interface(lhs), Interface(rhs)) => lhs.cmp(rhs),
             (Dependency(lhs), Dependency(rhs)) => lhs.cmp(rhs),
             (Url(lhs), Url(rhs)) => lhs.cmp(rhs),
             (Hash(lhs), Hash(rhs)) => lhs.cmp(rhs),
 
             (Label(_), _)
+            | (Implements(_), _)
             | (Constructor(_), _)
             | (Method(_), _)
             | (Static(_), _)
@@ -455,7 +487,11 @@ impl Hash for ComponentNameKind<'_> {
     fn hash<H: Hasher>(&self, hasher: &mut H) {
         use ComponentNameKind::*;
         match self {
+            // `[implements=<I>]L` hashes the same as bare label `L` since
+            // they conflict on the same label.
             Label(name) => (0u8, name).hash(hasher),
+            Implements(name) => (0u8, name.label()).hash(hasher),
+
             Constructor(name) => (1u8, name).hash(hasher),
 
             Method(name) | Static(name) => {
@@ -508,6 +544,37 @@ impl<'a> ResourceFunc<'a> {
     }
 }
 
+/// An implements name, representing `[implements=<I>]L`.
+///
+/// The internal string starts after `[implements=<` and contains
+/// `interface_name>]label`.
+#[derive(Debug, Clone)]
+pub struct ImplementsName<'a>(&'a str);
+
+impl<'a> ImplementsName<'a> {
+    /// Returns the full raw string of the implements name (everything after
+    /// the `[implements=<` prefix).
+    pub fn as_str(&self) -> &'a str {
+        self.0
+    }
+
+    /// Returns the index of `>]` in the internal string, which separates the
+    /// interface name from the label.
+    fn split_point(&self) -> usize {
+        self.0.find(">]").unwrap()
+    }
+
+    /// Returns the interface name (the `I` in `[implements=<I>]L`).
+    pub fn interface(&self) -> &'a str {
+        &self.0[..self.split_point()]
+    }
+
+    /// Returns the label (the `L` in `[implements=<I>]L`).
+    pub fn label(&self) -> &'a KebabStr {
+        KebabStr::new_unchecked(&self.0[self.split_point() + 2..])
+    }
+}
+
 /// An interface name, stored as `a:b/c@1.2.3`
 #[derive(Debug, Clone, Hash, Eq, PartialEq, Ord, PartialOrd)]
 pub struct InterfaceName<'a>(&'a str);
@@ -616,6 +683,29 @@ impl<'a> ComponentNameParser<'a> {
             return Ok(ParsedComponentNameKind::Static);
         }
 
+        // '[implements=<' <interfacename> '>]' <label>
+        if self.eat_str(IMPLEMENTS_PREFIX) {
+            let iface_str = self.take_up_to('>')?;
+            // Validate the interface name by parsing it as a package name
+            // with a required projection (e.g. `ns:pkg/iface`).
+            let mut iface_parser = ComponentNameParser {
+                next: iface_str,
+                offset: self.offset,
+                features: self.features,
+            };
+            iface_parser.pkg_name(true)?;
+            if !iface_parser.next.is_empty() {
+                bail!(
+                    self.offset,
+                    "trailing content after interface name in implements annotation"
+                );
+            }
+            self.expect_str(">")?;
+            self.expect_str("]")?;
+            self.expect_kebab()?;
+            return Ok(ParsedComponentNameKind::Implements);
+        }
+
         // 'unlocked-dep=<' <pkgnamequery> '>'
         if self.eat_str("unlocked-dep=") {
             self.expect_str("<")?;
@@ -962,6 +1052,19 @@ mod tests {
         assert!(parse_kebab_name("[method]a.b.c").is_none());
         assert!(parse_kebab_name("[static]a.b").is_some());
         assert!(parse_kebab_name("[static]a").is_none());
+
+        // implements names
+        assert!(parse_kebab_name("[implements=<a:b/c>]name").is_some());
+        assert!(parse_kebab_name("[implements=<a:b/c@1.0.0>]name").is_some());
+        assert!(parse_kebab_name("[implements=<ns:pkg/iface>]my-label").is_some());
+        // invalid: not a valid interface name (no colon/slash)
+        assert!(parse_kebab_name("[implements=<not-valid>]name").is_none());
+        // invalid: empty interface name
+        assert!(parse_kebab_name("[implements=<>]name").is_none());
+        // invalid: missing label
+        assert!(parse_kebab_name("[implements=<a:b/c>]").is_none());
+        // invalid: label not kebab
+        assert!(parse_kebab_name("[implements=<a:b/c>]NOT_KEBAB").is_none());
     }
 
     #[test]
@@ -1014,4 +1117,105 @@ mod tests {
         assert!(!s.insert(parse_kebab_name("[static]a.b")));
         assert!(s.insert(parse_kebab_name("[static]b.b")));
     }
+
+    #[test]
+    fn implements_name_parts() {
+        let name = parse_kebab_name("[implements=<a:b/c>]my-label").unwrap();
+        match name.kind() {
+            ComponentNameKind::Implements(imp) => {
+                assert_eq!(imp.interface(), "a:b/c");
+                assert_eq!(imp.label().as_str(), "my-label");
+            }
+            other => panic!("expected Implements, got {other:?}"),
+        }
+
+        let name = parse_kebab_name("[implements=<ns:pkg/iface@1.2.3>]the-name").unwrap();
+        match name.kind() {
+            ComponentNameKind::Implements(imp) => {
+                assert_eq!(imp.interface(), "ns:pkg/iface@1.2.3");
+                assert_eq!(imp.label().as_str(), "the-name");
+            }
+            other => panic!("expected Implements, got {other:?}"),
+        }
+    }
+
+    #[test]
+    fn implements_name_equality() {
+        // Same label conflicts, even with different interfaces
+        assert_eq!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("[implements=<x:y/z>]name"),
+        );
+
+        // Implements conflicts with bare label
+        assert_eq!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("name"),
+        );
+
+        // Different labels are strongly unique
+        assert_ne!(
+            parse_kebab_name("[implements=<a:b/c>]one"),
+            parse_kebab_name("[implements=<a:b/c>]two"),
+        );
+
+        // Implements is strongly unique from interface names
+        assert_ne!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("a:b/c"),
+        );
+
+        // HashSet uniqueness
+        let mut s = HashSet::new();
+        assert!(s.insert(parse_kebab_name("[implements=<a:b/c>]one")));
+        assert!(s.insert(parse_kebab_name("[implements=<a:b/c>]two")));
+        // same label conflicts
+        assert!(!s.insert(parse_kebab_name("[implements=<x:y/z>]one")));
+        // bare label conflicts with implements label
+        assert!(!s.insert(parse_kebab_name("one")));
+        // interface name is a different kind, no conflict
+        assert!(s.insert(parse_kebab_name("a:b/c")));
+    }
+
+    #[test]
+    fn implements_cross_kind_uniqueness() {
+        // Implements is strongly unique from constructor
+        assert_ne!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("[constructor]name"),
+        );
+
+        // Implements is strongly unique from method (different resource.method)
+        assert_ne!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("[method]name.other"),
+        );
+
+        // Implements is strongly unique from static (different resource.method)
+        assert_ne!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("[static]name.other"),
+        );
+
+        // The l.l edge case: [method]name.name equals bare "name",
+        // and [implements=<I>]name also equals bare "name",
+        // so they must be equal to each other.
+        assert_eq!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("[method]name.name"),
+        );
+        assert_eq!(
+            parse_kebab_name("[implements=<a:b/c>]name"),
+            parse_kebab_name("[static]name.name"),
+        );
+
+        // HashSet: implements, constructor, and method with different
+        // resource.method should all coexist
+        let mut s = HashSet::new();
+        assert!(s.insert(parse_kebab_name("[implements=<a:b/c>]name")));
+        assert!(s.insert(parse_kebab_name("[constructor]name")));
+        assert!(s.insert(parse_kebab_name("[method]name.other")));
+        // But [method]name.name conflicts (l.l edge case)
+        assert!(!s.insert(parse_kebab_name("[method]name.name")));
+    }
 }
diff --git a/crates/wit-component/src/encoding.rs b/crates/wit-component/src/encoding.rs
index 0379689d01..95ff0d5e1d 100644
--- a/crates/wit-component/src/encoding.rs
+++ b/crates/wit-component/src/encoding.rs
@@ -401,6 +401,7 @@ pub struct EncodingState<'a> {
 
     /// Imported instances and what index they were imported as.
     imported_instances: IndexMap<InterfaceId, u32>,
+    imported_instances_by_name: HashMap<String, u32>,
     imported_funcs: IndexMap<String, u32>,
     exported_instances: IndexMap<InterfaceId, u32>,
 
@@ -456,6 +457,18 @@ impl<'a> EncodingState<'a> {
         }
     }
 
+    fn world_import_name(&self, key: &WorldKey) -> String {
+        let resolve = &self.info.encoder.metadata.resolve;
+        let world = &resolve.worlds[self.info.encoder.metadata.world];
+        resolve.name_world_key_with_item(key, &world.imports[key])
+    }
+
+    fn world_export_name(&self, key: &WorldKey) -> String {
+        let resolve = &self.info.encoder.metadata.resolve;
+        let world = &resolve.worlds[self.info.encoder.metadata.world];
+        resolve.name_world_key_with_item(key, &world.exports[key])
+    }
+
     fn root_import_type_encoder(
         &mut self,
         interface: Option<InterfaceId>,
@@ -492,7 +505,8 @@ impl<'a> EncodingState<'a> {
         for (name, info) in self.info.import_map.iter() {
             match name {
                 Some(name) => {
-                    self.encode_interface_import(name_map.get(name).unwrap_or(name), info)?
+                    let import_name = name_map.get(name).unwrap_or(name);
+                    self.encode_interface_import(import_name, name, info)?
                 }
                 None => has_funcs = true,
             }
@@ -517,7 +531,12 @@ impl<'a> EncodingState<'a> {
         Ok(())
     }
 
-    fn encode_interface_import(&mut self, name: &str, info: &ImportedInterface) -> Result<()> {
+    fn encode_interface_import(
+        &mut self,
+        name: &str,
+        import_key: &str,
+        info: &ImportedInterface,
+    ) -> Result<()> {
         let resolve = &self.info.encoder.metadata.resolve;
         let interface_id = info.interface.as_ref().unwrap();
         let interface_id = *interface_id;
@@ -566,8 +585,11 @@ impl<'a> EncodingState<'a> {
         let instance_idx = self
             .component
             .import(name, ComponentTypeRef::Instance(instance_type_idx));
-        let prev = self.imported_instances.insert(interface_id, instance_idx);
-        assert!(prev.is_none());
+        self.imported_instances
+            .entry(interface_id)
+            .or_insert(instance_idx);
+        self.imported_instances_by_name
+            .insert(import_key.to_string(), instance_idx);
         Ok(())
     }
 
@@ -704,9 +726,9 @@ impl<'a> EncodingState<'a> {
                     let prev = world_func_core_names.insert(name, core_name);
                     assert!(prev.is_none());
                 }
-                Export::InterfaceFunc(_, id, name, _) => {
+                Export::InterfaceFunc(key, _id, name, _) => {
                     let prev = interface_func_core_names
-                        .entry(id)
+                        .entry(key)
                         .or_insert(IndexMap::new())
                         .insert(name.as_str(), core_name);
                     assert!(prev.is_none());
@@ -731,7 +753,7 @@ impl<'a> EncodingState<'a> {
         let world = &resolve.worlds[self.info.encoder.metadata.world];
 
         for export_name in exports {
-            let export_string = resolve.name_world_key(export_name);
+            let export_string = self.world_export_name(export_name);
             match &world.exports[export_name] {
                 WorldItem::Function(func) => {
                     let ty = self
@@ -743,7 +765,7 @@ impl<'a> EncodingState<'a> {
                         .export(&export_string, ComponentExportKind::Func, idx, None);
                 }
                 WorldItem::Interface { id, .. } => {
-                    let core_names = interface_func_core_names.get(id);
+                    let core_names = interface_func_core_names.get(export_name);
                     self.encode_interface_export(
                         &export_string,
                         module,
@@ -966,8 +988,7 @@ impl<'a> EncodingState<'a> {
             instance_index,
             None,
         );
-        let prev = self.exported_instances.insert(export, idx);
-        assert!(prev.is_none());
+        self.exported_instances.entry(export).or_insert(idx);
 
         // After everything is all said and done remove all the type information
         // about type exports of this interface. Any entries in the map
@@ -1292,11 +1313,12 @@ impl<'a> EncodingState<'a> {
                     realloc,
                     encoding,
                 } => {
-                    let interface = &self.info.import_map[interface];
-                    let ((name, _), _) = interface.lowerings.get_index(*index).unwrap();
-                    let func_index = match &interface.interface {
-                        Some(interface_id) => {
-                            let instance_index = self.imported_instances[interface_id];
+                    let import = &self.info.import_map[interface];
+                    let ((name, _), _) = import.lowerings.get_index(*index).unwrap();
+                    let func_index = match interface {
+                        Some(iface_key) => {
+                            let instance_index =
+                                self.imported_instances_by_name[iface_key.as_str()];
                             self.component.alias_export(
                                 instance_index,
                                 name,
@@ -1309,7 +1331,7 @@ impl<'a> EncodingState<'a> {
                     let realloc = self
                         .info
                         .exports_for(*realloc)
-                        .import_realloc_for(interface.interface, name)
+                        .import_realloc_for(import.interface, name)
                         .map(|name| {
                             let instance = self.instance_for(*realloc);
                             self.core_alias_export(
@@ -1785,7 +1807,7 @@ impl<'a> EncodingState<'a> {
                 self.materialize_wit_import(
                     shims,
                     for_module,
-                    iface.map(|_| resolve.name_world_key(key)),
+                    iface.map(|_| self.world_import_name(key)),
                     &format!("{name}_drop"),
                     key,
                     AbiVariant::GuestImport,
@@ -1955,7 +1977,7 @@ impl<'a> EncodingState<'a> {
             Import::InterfaceFunc(key, _, name, abi) => self.materialize_wit_import(
                 shims,
                 for_module,
-                Some(resolve.name_world_key(key)),
+                Some(self.world_import_name(key)),
                 name,
                 key,
                 *abi,
@@ -2072,9 +2094,9 @@ impl<'a> EncodingState<'a> {
             // All direct lowerings can be `canon lower`'d here immediately
             // and passed as arguments.
             Lowering::Direct => {
-                let func_index = match &import.interface {
-                    Some(interface) => {
-                        let instance_index = self.imported_instances[interface];
+                let func_index = match &interface_key {
+                    Some(iface_key) => {
+                        let instance_index = self.imported_instances_by_name[iface_key.as_str()];
                         self.component
                             .alias_export(instance_index, name, ComponentExportKind::Func)
                     }
@@ -2849,6 +2871,7 @@ impl<'a> Shims<'a> {
                 // metadata out of this `match` to the loop below to figure that
                 // out.
                 Import::InterfaceFunc(key, _, name, abi) => {
+                    let wit_world = &resolve.worlds[world.encoder.metadata.world];
                     self.append_indirect_wit_func(
                         world,
                         for_module,
@@ -2856,7 +2879,7 @@ impl<'a> Shims<'a> {
                         field,
                         key,
                         name,
-                        Some(resolve.name_world_key(key)),
+                        Some(resolve.name_world_key_with_item(key, &wit_world.imports[key])),
                         *abi,
                     )?;
                 }
@@ -3343,6 +3366,7 @@ impl ComponentEncoder {
             import_type_encoding_maps: Default::default(),
             export_type_encoding_maps: Default::default(),
             imported_instances: Default::default(),
+            imported_instances_by_name: Default::default(),
             imported_funcs: Default::default(),
             exported_instances: Default::default(),
             aliased_core_items: Default::default(),
diff --git a/crates/wit-component/src/encoding/wit.rs b/crates/wit-component/src/encoding/wit.rs
index 93fb729be7..b1c75aa1d7 100644
--- a/crates/wit-component/src/encoding/wit.rs
+++ b/crates/wit-component/src/encoding/wit.rs
@@ -73,7 +73,7 @@ pub fn encode_world(resolve: &Resolve, world_id: WorldId) -> Result<ComponentTyp
 
     // Encode the imports
     for (name, import) in world.imports.iter() {
-        let name = resolve.name_world_key(name);
+        let name = resolve.name_world_key_with_item(name, import);
         log::trace!("encoding import {name}");
         let ty = match import {
             WorldItem::Interface { id, .. } => {
@@ -98,7 +98,7 @@ pub fn encode_world(resolve: &Resolve, world_id: WorldId) -> Result<ComponentTyp
     }
     // Encode the exports
     for (name, export) in world.exports.iter() {
-        let name = resolve.name_world_key(name);
+        let name = resolve.name_world_key_with_item(name, export);
         log::trace!("encoding export {name}");
         let ty = match export {
             WorldItem::Interface { id, .. } => {
diff --git a/crates/wit-component/src/encoding/world.rs b/crates/wit-component/src/encoding/world.rs
index 8ea1d4af13..a2b0600ae0 100644
--- a/crates/wit-component/src/encoding/world.rs
+++ b/crates/wit-component/src/encoding/world.rs
@@ -248,7 +248,7 @@ impl<'a> ComponentWorld<'a> {
             item: &WorldItem,
             required: &Required<'_>,
         ) -> Result<()> {
-            let name = resolve.name_world_key(name);
+            let name = resolve.name_world_key_with_item(name, item);
             log::trace!("register import `{name}`");
             let import_map_key = match item {
                 WorldItem::Function(_) | WorldItem::Type { .. } => None,
@@ -314,7 +314,10 @@ impl<'a> ComponentWorld<'a> {
         // set. This means that only types not defined by referenced exports
         // will get added here.
         for (name, item) in resolve.worlds[world].exports.iter() {
-            log::trace!("add live world export `{}`", resolve.name_world_key(name));
+            log::trace!(
+                "add live world export `{}`",
+                resolve.name_world_key_with_item(name, item)
+            );
             let id = match item {
                 WorldItem::Interface { id, .. } => id,
                 WorldItem::Function(_) | WorldItem::Type { .. } => {
@@ -453,6 +456,10 @@ impl<'a> ComponentWorld<'a> {
                 WorldItem::Interface { id, .. } => *id,
                 WorldItem::Type { .. } => unreachable!(),
             };
+            // Skip already-processed interfaces (implements duplicates).
+            if self.exports_used.contains_key(&id) {
+                continue;
+            }
             let mut set = HashSet::new();
 
             for other in resolve.interface_direct_deps(id) {
diff --git a/crates/wit-component/src/printing.rs b/crates/wit-component/src/printing.rs
index dffb936cf2..dfab2b39cd 100644
--- a/crates/wit-component/src/printing.rs
+++ b/crates/wit-component/src/printing.rs
@@ -468,6 +468,17 @@ impl<O: Output> WitPrinter<O> {
         match name {
             WorldKey::Name(name) => {
                 match item {
+                    WorldItem::Interface {
+                        id,
+                        implements: Some(_),
+                        ..
+                    } => {
+                        // `import label: use-path;` syntax
+                        self.print_name_type(name, TypeKind::Other);
+                        self.output.str(": ");
+                        self.print_path_to_interface(resolve, *id, cur_pkg)?;
+                        self.output.semicolon();
+                    }
                     WorldItem::Interface { id, .. } => {
                         self.print_name_type(name, TypeKind::Other);
                         self.output.str(": ");
diff --git a/crates/wit-component/tests/interfaces/implements.wat b/crates/wit-component/tests/interfaces/implements.wat
new file mode 100644
index 0000000000..eeaf0720eb
--- /dev/null
+++ b/crates/wit-component/tests/interfaces/implements.wat
@@ -0,0 +1,130 @@
+(component
+  (type (;0;)
+    (component
+      (type (;0;)
+        (instance
+          (type (;0;) (option string))
+          (type (;1;) (func (param "key" string) (result 0)))
+          (export (;0;) "get" (func (type 1)))
+          (type (;2;) (func (param "key" string) (param "value" string)))
+          (export (;1;) "set" (func (type 2)))
+        )
+      )
+      (export (;0;) "foo:foo/store" (instance (type 0)))
+    )
+  )
+  (export (;1;) "store" (type 0))
+  (type (;2;)
+    (component
+      (type (;0;)
+        (instance
+          (type (;0;) (func (param "msg" string)))
+          (export (;0;) "log" (func (type 0)))
+        )
+      )
+      (export (;0;) "foo:foo/logger" (instance (type 0)))
+    )
+  )
+  (export (;3;) "logger" (type 2))
+  (type (;4;)
+    (component
+      (type (;0;)
+        (component
+          (type (;0;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "[implements=<foo:foo/store>]primary" (instance (;0;) (type 0)))
+          (type (;1;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "[implements=<foo:foo/store>]backup" (instance (;1;) (type 1)))
+          (type (;2;)
+            (instance
+              (type (;0;) (func (param "msg" string)))
+              (export (;0;) "log" (func (type 0)))
+            )
+          )
+          (import "foo:foo/logger" (instance (;2;) (type 2)))
+        )
+      )
+      (export (;0;) "foo:foo/multi-import" (component (type 0)))
+    )
+  )
+  (export (;5;) "multi-import" (type 4))
+  (type (;6;)
+    (component
+      (type (;0;)
+        (component
+          (type (;0;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (export (;0;) "[implements=<foo:foo/store>]primary" (instance (type 0)))
+          (type (;1;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (export (;1;) "[implements=<foo:foo/store>]backup" (instance (type 1)))
+        )
+      )
+      (export (;0;) "foo:foo/multi-export" (component (type 0)))
+    )
+  )
+  (export (;7;) "multi-export" (type 6))
+  (type (;8;)
+    (component
+      (type (;0;)
+        (component
+          (type (;0;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "foo:foo/store" (instance (;0;) (type 0)))
+          (type (;1;)
+            (instance
+              (type (;0;) (option string))
+              (type (;1;) (func (param "key" string) (result 0)))
+              (export (;0;) "get" (func (type 1)))
+              (type (;2;) (func (param "key" string) (param "value" string)))
+              (export (;1;) "set" (func (type 2)))
+            )
+          )
+          (import "[implements=<foo:foo/store>]cache" (instance (;1;) (type 1)))
+        )
+      )
+      (export (;0;) "foo:foo/mixed" (component (type 0)))
+    )
+  )
+  (export (;9;) "mixed" (type 8))
+  (@custom "package-docs" "\01{\22worlds\22:{\22multi-import\22:{\22docs\22:\22A world that imports the same interface multiple times under different\5cnplain names using the `implements` syntax.\22},\22multi-export\22:{\22docs\22:\22A world that exports the same interface multiple times.\22},\22mixed\22:{\22docs\22:\22A world with both implements imports and a normal interface import,\5cntesting that elaboration adds the dependency correctly.\22}}}")
+  (@producers
+    (processed-by "wit-component" "$CARGO_PKG_VERSION")
+  )
+)
diff --git a/crates/wit-component/tests/interfaces/implements.wit b/crates/wit-component/tests/interfaces/implements.wit
new file mode 100644
index 0000000000..0aa5578534
--- /dev/null
+++ b/crates/wit-component/tests/interfaces/implements.wit
@@ -0,0 +1,31 @@
+package foo:foo;
+
+interface store {
+  get: func(key: string) -> option<string>;
+  set: func(key: string, value: string);
+}
+
+interface logger {
+  log: func(msg: string);
+}
+
+/// A world that imports the same interface multiple times under different
+/// plain names using the `implements` syntax.
+world multi-import {
+  import primary: store;
+  import backup: store;
+  import logger;
+}
+
+/// A world that exports the same interface multiple times.
+world multi-export {
+  export primary: store;
+  export backup: store;
+}
+
+/// A world with both implements imports and a normal interface import,
+/// testing that elaboration adds the dependency correctly.
+world mixed {
+  import store;
+  import cache: store;
+}
diff --git a/crates/wit-component/tests/interfaces/implements.wit.print b/crates/wit-component/tests/interfaces/implements.wit.print
new file mode 100644
index 0000000000..86c3044f08
--- /dev/null
+++ b/crates/wit-component/tests/interfaces/implements.wit.print
@@ -0,0 +1,30 @@
+package foo:foo;
+
+interface store {
+  get: func(key: string) -> option<string>;
+
+  set: func(key: string, value: string);
+}
+
+interface logger {
+  log: func(msg: string);
+}
+
+/// A world that imports the same interface multiple times under different
+/// plain names using the `implements` syntax.
+world multi-import {
+  import primary: store;
+  import backup: store;
+  import logger;
+}
+/// A world that exports the same interface multiple times.
+world multi-export {
+  export primary: store;
+  export backup: store;
+}
+/// A world with both implements imports and a normal interface import,
+/// testing that elaboration adds the dependency correctly.
+world mixed {
+  import store;
+  import cache: store;
+}
diff --git a/crates/wit-dylib/tests/roundtrip.rs b/crates/wit-dylib/tests/roundtrip.rs
index c32d03881f..02b997e2b5 100644
--- a/crates/wit-dylib/tests/roundtrip.rs
+++ b/crates/wit-dylib/tests/roundtrip.rs
@@ -88,6 +88,7 @@ fn run_one(u: &mut Unstructured<'_>) -> Result<()> {
                 WorldItem::Interface {
                     id: *id,
                     stability: Default::default(),
+                    implements: None,
                     span: Default::default(),
                 },
             )
@@ -201,6 +202,7 @@ fn run_one(u: &mut Unstructured<'_>) -> Result<()> {
         WorldItem::Interface {
             id: alloc,
             stability: Default::default(),
+            implements: None,
             span: Default::default(),
         },
     );
@@ -209,6 +211,7 @@ fn run_one(u: &mut Unstructured<'_>) -> Result<()> {
         WorldItem::Interface {
             id: alloc,
             stability: Default::default(),
+            implements: None,
             span: Default::default(),
         },
     );
diff --git a/crates/wit-parser/src/ast.rs b/crates/wit-parser/src/ast.rs
index 7148cd67fb..63277dc056 100644
--- a/crates/wit-parser/src/ast.rs
+++ b/crates/wit-parser/src/ast.rs
@@ -205,7 +205,7 @@ impl<'a> DeclList<'a> {
                                 }
                                 Ok(())
                             }
-                            ExternKind::Path(path) => {
+                            ExternKind::Path(path) | ExternKind::NamedPath(_, path) => {
                                 f(None, attrs, path, None, WorldOrInterface::Interface)
                             }
                             ExternKind::Func(..) => Ok(()),
@@ -480,6 +480,8 @@ enum ExternKind<'a> {
     Interface(Id<'a>, Vec<InterfaceItem<'a>>),
     Path(UsePath<'a>),
     Func(Id<'a>, Func<'a>),
+    /// `label: use-path` — a named import/export that implements an interface.
+    NamedPath(Id<'a>, UsePath<'a>),
 }
 
 impl<'a> ExternKind<'a> {
@@ -508,6 +510,26 @@ impl<'a> ExternKind<'a> {
                 *tokens = clone;
                 return Ok(ExternKind::Interface(id, Interface::parse_items(tokens)?));
             }
+
+            // import label: use-path
+            // At this point we consumed `id:` on the clone but the next token
+            // is not `func`, `async`, or `interface`. This could be either:
+            //   import label: local-iface;          (NamedPath)
+            //   import label: pkg:name/iface;       (NamedPath with package path)
+            //   import ns:pkg/iface;                (regular fully-qualified Path)
+            //
+            // Disambiguate: if the next tokens are `id /`, then the colon was
+            // part of a fully-qualified `namespace:package/interface` name, not
+            // a label separator. Fall through to the Path parser in that case.
+            let mut peek = clone.clone();
+            let is_qualified_path =
+                parse_id(&mut peek).is_ok() && peek.clone().eat(Token::Slash).unwrap_or(false);
+            if !is_qualified_path {
+                *tokens = clone;
+                let path = UsePath::parse(tokens)?;
+                tokens.expect_semicolon()?;
+                return Ok(ExternKind::NamedPath(id, path));
+            }
         }
 
         // import foo
@@ -524,6 +546,7 @@ impl<'a> ExternKind<'a> {
             ExternKind::Path(UsePath::Id(id)) => id.span,
             ExternKind::Path(UsePath::Package { name, .. }) => name.span,
             ExternKind::Func(id, _) => id.span,
+            ExternKind::NamedPath(id, _) => id.span,
         }
     }
 }
diff --git a/crates/wit-parser/src/ast/resolve.rs b/crates/wit-parser/src/ast/resolve.rs
index e77ac0f260..ba5d5ec539 100644
--- a/crates/wit-parser/src/ast/resolve.rs
+++ b/crates/wit-parser/src/ast/resolve.rs
@@ -701,8 +701,18 @@ impl<'a> Resolver<'a> {
                     let id = self.extract_iface_from_item(&item, &name, span)?;
                     WorldKey::Interface(id)
                 }
+
+                // Named paths use the label as the key.
+                ast::ExternKind::NamedPath(name, _) => WorldKey::Name(name.name.to_string()),
             };
-            if let WorldItem::Interface { id, .. } = world_item {
+            if let WorldItem::Interface {
+                id,
+                implements: None,
+                ..
+            } = world_item
+            {
+                // Only enforce the single-import restriction for bare
+                // `ExternKind::Path` imports (not named/implements imports).
                 if !interfaces.insert(id) {
                     bail!(Error::new(
                         kind.span(),
@@ -753,6 +763,7 @@ impl<'a> Resolver<'a> {
                 Ok(WorldItem::Interface {
                     id,
                     stability,
+                    implements: None,
                     span: name.span,
                 })
             }
@@ -763,9 +774,21 @@ impl<'a> Resolver<'a> {
                 Ok(WorldItem::Interface {
                     id,
                     stability,
+                    implements: None,
                     span: item_span,
                 })
             }
+            ast::ExternKind::NamedPath(name, path) => {
+                let stability = self.stability(attrs)?;
+                let (item, iface_name, item_span) = self.resolve_ast_item_path(path)?;
+                let id = self.extract_iface_from_item(&item, &iface_name, item_span)?;
+                Ok(WorldItem::Interface {
+                    id,
+                    stability,
+                    implements: Some(id),
+                    span: name.span,
+                })
+            }
             ast::ExternKind::Func(name, func) => {
                 let func = self.resolve_function(
                     docs,
diff --git a/crates/wit-parser/src/decoding.rs b/crates/wit-parser/src/decoding.rs
index 88253a3b6e..31660782cc 100644
--- a/crates/wit-parser/src/decoding.rs
+++ b/crates/wit-parser/src/decoding.rs
@@ -18,6 +18,19 @@ use wasmparser::{
     types::Types,
 };
 
+/// Parses an `[implements=<interface_name>]label` name, returning
+/// the interface name and label if the name matches this pattern.
+fn parse_implements_name(name: &str) -> Option<(&str, &str)> {
+    let rest = name.strip_prefix("[implements=<")?;
+    let end = rest.find(">]")?;
+    let interface = &rest[..end];
+    let label = &rest[end + 2..];
+    if interface.is_empty() || label.is_empty() {
+        return None;
+    }
+    Some((interface, label))
+}
+
 /// Represents information about a decoded WebAssembly component.
 struct ComponentInfo {
     /// Wasmparser-defined type information learned after a component is fully
@@ -654,21 +667,8 @@ impl WitPackageDecoder<'_> {
         let (name, item) = match ty {
             ComponentEntityType::Instance(i) => {
                 let ty = &self.types[i];
-                let (name, id) = if name.contains('/') {
-                    let id = self.register_import(name, ty)?;
-                    (WorldKey::Interface(id), id)
-                } else {
-                    self.register_interface(name, ty, package)
-                        .with_context(|| format!("failed to decode WIT from import `{name}`"))?
-                };
-                (
-                    name,
-                    WorldItem::Interface {
-                        id,
-                        stability: Default::default(),
-                        span: Default::default(),
-                    },
-                )
+                self.decode_world_instance(name, ty, package)
+                    .with_context(|| format!("failed to decode WIT from import `{name}`"))?
             }
             ComponentEntityType::Func(i) => {
                 let ty = &self.types[i];
@@ -720,21 +720,8 @@ impl WitPackageDecoder<'_> {
             }
             ComponentEntityType::Instance(i) => {
                 let ty = &types[i];
-                let (name, id) = if name.contains('/') {
-                    let id = self.register_import(name, ty)?;
-                    (WorldKey::Interface(id), id)
-                } else {
-                    self.register_interface(name, ty, package)
-                        .with_context(|| format!("failed to decode WIT from export `{name}`"))?
-                };
-                (
-                    name,
-                    WorldItem::Interface {
-                        id,
-                        stability: Default::default(),
-                        span: Default::default(),
-                    },
-                )
+                self.decode_world_instance(name, ty, package)
+                    .with_context(|| format!("failed to decode WIT from export `{name}`"))?
             }
             _ => {
                 bail!("component export `{name}` was not a function or instance")
@@ -744,6 +731,55 @@ impl WitPackageDecoder<'_> {
         Ok(())
     }
 
+    /// Decodes a component instance import/export name into a
+    /// `(WorldKey, WorldItem)` pair.
+    ///
+    /// Handles three name forms:
+    /// - `[implements=<I>]label` — named import/export implementing interface I
+    /// - `ns:pkg/iface` — qualified interface name, keyed by `InterfaceId`
+    /// - `plain-name` — unqualified name for an inline or local interface
+    fn decode_world_instance<'a>(
+        &mut self,
+        name: &str,
+        ty: &ComponentInstanceType,
+        package: &mut PackageFields<'a>,
+    ) -> Result<(WorldKey, WorldItem)> {
+        if let Some((iface_name, label)) = parse_implements_name(name) {
+            let id = self.register_import(iface_name, ty)?;
+            Ok((
+                WorldKey::Name(label.to_string()),
+                WorldItem::Interface {
+                    id,
+                    stability: Default::default(),
+                    implements: Some(id),
+                    span: Default::default(),
+                },
+            ))
+        } else if name.contains('/') {
+            let id = self.register_import(name, ty)?;
+            Ok((
+                WorldKey::Interface(id),
+                WorldItem::Interface {
+                    id,
+                    stability: Default::default(),
+                    implements: None,
+                    span: Default::default(),
+                },
+            ))
+        } else {
+            let (key, id) = self.register_interface(name, ty, package)?;
+            Ok((
+                key,
+                WorldItem::Interface {
+                    id,
+                    stability: Default::default(),
+                    implements: None,
+                    span: Default::default(),
+                },
+            ))
+        }
+    }
+
     /// Registers that the `name` provided is either imported interface from a
     /// foreign package or  referencing a previously defined interface in this
     /// package.
@@ -1111,27 +1147,7 @@ impl WitPackageDecoder<'_> {
             let (name, item) = match ty {
                 ComponentEntityType::Instance(idx) => {
                     let ty = &self.types[*idx];
-                    let (name, id) = if name.contains('/') {
-                        // If a name is an interface import then it is either to
-                        // a package-local or foreign interface, and both
-                        // situations are handled in `register_import`.
-                        let id = self.register_import(name, ty)?;
-                        (WorldKey::Interface(id), id)
-                    } else {
-                        // A plain kebab-name indicates an inline interface that
-                        // wasn't declared explicitly elsewhere with a name, and
-                        // `register_interface` will create a new `Interface`
-                        // with no name.
-                        self.register_interface(name, ty, package)?
-                    };
-                    (
-                        name,
-                        WorldItem::Interface {
-                            id,
-                            stability: Default::default(),
-                            span: Default::default(),
-                        },
-                    )
+                    self.decode_world_instance(name, ty, package)?
                 }
                 ComponentEntityType::Type {
                     created,
@@ -1161,26 +1177,7 @@ impl WitPackageDecoder<'_> {
             let (name, item) = match ty {
                 ComponentEntityType::Instance(idx) => {
                     let ty = &self.types[*idx];
-                    let (name, id) = if name.contains('/') {
-                        // Note that despite this being an export this is
-                        // calling `register_import`. With a URL this interface
-                        // must have been previously defined so this will
-                        // trigger the logic of either filling in a remotely
-                        // defined interface or connecting items to local
-                        // definitions of our own interface.
-                        let id = self.register_import(name, ty)?;
-                        (WorldKey::Interface(id), id)
-                    } else {
-                        self.register_interface(name, ty, package)?
-                    };
-                    (
-                        name,
-                        WorldItem::Interface {
-                            id,
-                            stability: Default::default(),
-                            span: Default::default(),
-                        },
-                    )
+                    self.decode_world_instance(name, ty, package)?
                 }
 
                 ComponentEntityType::Func(idx) => {
@@ -1254,8 +1251,9 @@ impl WitPackageDecoder<'_> {
                     }
                 }
 
-                // Functions shouldn't have ID-based names at this time.
+                // Functions shouldn't have ID-based or implements names.
                 ComponentNameKind::Interface(_)
+                | ComponentNameKind::Implements(_)
                 | ComponentNameKind::Url(_)
                 | ComponentNameKind::Hash(_)
                 | ComponentNameKind::Dependency(_) => unreachable!(),
@@ -1572,8 +1570,14 @@ impl WitPackageDecoder<'_> {
             world.package = Some(pkg);
             for (name, item) in world.imports.iter().chain(world.exports.iter()) {
                 if let WorldKey::Name(_) = name {
-                    if let WorldItem::Interface { id, .. } = item {
-                        self.resolve.interfaces[*id].package = Some(pkg);
+                    if let WorldItem::Interface { id, implements, .. } = item {
+                        // Only reassign the package for anonymous (inline)
+                        // interfaces. Implements items use `WorldKey::Name`
+                        // but reference interfaces from other packages that
+                        // must keep their original package assignment.
+                        if implements.is_none() {
+                            self.resolve.interfaces[*id].package = Some(pkg);
+                        }
                     }
                 }
             }
diff --git a/crates/wit-parser/src/lib.rs b/crates/wit-parser/src/lib.rs
index 132dbc99e8..0a121164d7 100644
--- a/crates/wit-parser/src/lib.rs
+++ b/crates/wit-parser/src/lib.rs
@@ -614,6 +614,18 @@ pub enum WorldItem {
             serde(skip_serializing_if = "Stability::is_unknown")
         )]
         stability: Stability,
+        /// When `Some`, the interface is imported/exported under a plain name
+        /// using the `[implements=<I>]label` encoding. The `InterfaceId` here
+        /// identifies the named interface `I` that this import/export
+        /// implements.
+        #[cfg_attr(
+            feature = "serde",
+            serde(
+                skip_serializing_if = "Option::is_none",
+                serialize_with = "serialize_optional_id"
+            )
+        )]
+        implements: Option<InterfaceId>,
         #[cfg_attr(feature = "serde", serde(skip))]
         span: Span,
     },
diff --git a/crates/wit-parser/src/resolve/mod.rs b/crates/wit-parser/src/resolve/mod.rs
index 12900fe4d0..8dfa742eaa 100644
--- a/crates/wit-parser/src/resolve/mod.rs
+++ b/crates/wit-parser/src/resolve/mod.rs
@@ -584,8 +584,11 @@ package {name} is defined in two different locations:\n\
                                 WorldItem::Function(f) => {
                                     remap.update_function(self, f, Default::default())?
                                 }
-                                WorldItem::Interface { id, .. } => {
-                                    *id = remap.map_interface(*id, Default::default())?
+                                WorldItem::Interface { id, implements, .. } => {
+                                    *id = remap.map_interface(*id, Default::default())?;
+                                    if let Some(imp) = implements {
+                                        *imp = remap.map_interface(*imp, Default::default())?;
+                                    }
                                 }
                                 WorldItem::Type { id, .. } => {
                                     *id = remap.map_type(*id, Default::default())?
@@ -647,6 +650,9 @@ package {name} is defined in two different locations:\n\
             if let Some(pkg) = self.interfaces[id].package.as_mut() {
                 *pkg = remap.packages[pkg.index()];
             }
+            if let Some(clone_of) = self.interfaces[id].clone_of.as_mut() {
+                *clone_of = remap.map_interface(*clone_of, Default::default())?;
+            }
         }
         for id in moved_types {
             let id = remap.map_type(id, Default::default())?;
@@ -1374,6 +1380,28 @@ package {name} is defined in two different locations:\n\
         }
     }
 
+    /// Produces the binary extern name for a world key + item pair.
+    ///
+    /// For items with `implements`, produces `[implements=<I>]label`.
+    /// Otherwise delegates to [`Resolve::name_world_key`].
+    pub fn name_world_key_with_item(&self, key: &WorldKey, item: &WorldItem) -> String {
+        if let (
+            WorldKey::Name(label),
+            WorldItem::Interface {
+                implements: Some(iface_id),
+                ..
+            },
+        ) = (key, item)
+        {
+            let iface_name = self
+                .id_of(*iface_id)
+                .expect("unexpected anonymous interface");
+            format!("[implements=<{iface_name}>]{label}")
+        } else {
+            self.name_world_key(key)
+        }
+    }
+
     /// Same as [`Resolve::name_world_key`] except that `WorldKey::Interfaces`
     /// uses [`Resolve::canonicalized_id_of`].
     pub fn name_canonicalized_world_key(&self, key: &WorldKey) -> String {
@@ -1552,11 +1580,18 @@ package {name} is defined in two different locations:\n\
             for (name, item) in world.imports.iter().chain(world.exports.iter()) {
                 log::debug!("validating world item: {}", self.name_world_key(name));
                 match item {
-                    WorldItem::Interface { id, .. } => {
-                        // anonymous interfaces must belong to the same package
-                        // as the world's package.
+                    WorldItem::Interface { id, implements, .. } => {
                         if matches!(name, WorldKey::Name(_)) {
-                            assert_eq!(self.interfaces[*id].package, world.package);
+                            if implements.is_none() {
+                                // Anonymous interfaces must belong to the same
+                                // package as the world's package.
+                                assert_eq!(self.interfaces[*id].package, world.package);
+                            } else {
+                                // Implements items use `WorldKey::Name` but can
+                                // reference interfaces from other packages.
+                                // Verify the target interface exists.
+                                assert!(self.interfaces.get(*id).is_some());
+                            }
                         }
                     }
                     WorldItem::Function(f) => {
@@ -1736,7 +1771,14 @@ package {name} is defined in two different locations:\n\
         if let TypeDefKind::Type(Type::Id(other)) = ty.kind {
             if let TypeOwner::Interface(id) = self.types[other].owner {
                 let key = WorldKey::Interface(id);
-                assert!(world.imports.contains_key(&key));
+                // The interface may be imported directly, or via an
+                // `implements` item under a different label (where the
+                // WorldItem's `id` is a clone of the implemented interface).
+                let imported = world.imports.contains_key(&key)
+                    || world.imports.values().any(
+                        |item| matches!(item, WorldItem::Interface { id: iid, .. } if *iid == id),
+                    );
+                assert!(imported);
                 return;
             }
         }
@@ -1932,8 +1974,19 @@ package {name} is defined in two different locations:\n\
             match item {
                 // Interfaces get their dependencies added first followed by the
                 // interface itself.
-                WorldItem::Interface { id, stability, .. } => {
-                    self.elaborate_world_import(&mut new_imports, name.clone(), *id, &stability);
+                WorldItem::Interface {
+                    id,
+                    stability,
+                    implements,
+                    ..
+                } => {
+                    self.elaborate_world_import(
+                        &mut new_imports,
+                        name.clone(),
+                        *id,
+                        &stability,
+                        *implements,
+                    );
                 }
 
                 // Functions are added as-is since their dependence on types in
@@ -1953,6 +2006,7 @@ package {name} is defined in two different locations:\n\
                             WorldKey::Interface(dep),
                             dep,
                             &self.types[*id].stability,
+                            None,
                         );
                     }
                     let prev = new_imports.insert(name.clone(), item.clone());
@@ -1967,12 +2021,18 @@ package {name} is defined in two different locations:\n\
         // the new exports list during this loop but interfaces are all deferred
         // to be handled in the `elaborate_world_exports` function.
         let mut new_exports = IndexMap::default();
-        let mut export_interfaces = IndexMap::default();
+        let mut export_interfaces = Vec::new();
+        let mut export_interface_ids = HashSet::new();
         for (name, item) in world.exports.iter() {
             match item {
-                WorldItem::Interface { id, stability, .. } => {
-                    let prev = export_interfaces.insert(*id, (name.clone(), stability));
-                    assert!(prev.is_none());
+                WorldItem::Interface {
+                    id,
+                    stability,
+                    implements,
+                    ..
+                } => {
+                    export_interfaces.push((*id, name.clone(), stability, *implements));
+                    export_interface_ids.insert(*id);
                 }
                 WorldItem::Function(_) => {
                     let prev = new_exports.insert(name.clone(), item.clone());
@@ -1982,7 +2042,12 @@ package {name} is defined in two different locations:\n\
             }
         }
 
-        self.elaborate_world_exports(&export_interfaces, &mut new_imports, &mut new_exports)?;
+        self.elaborate_world_exports(
+            &export_interfaces,
+            &export_interface_ids,
+            &mut new_imports,
+            &mut new_exports,
+        )?;
 
         // In addition to sorting at the start of elaboration also sort here at
         // the end of elaboration to handle types being interspersed with
@@ -2006,18 +2071,20 @@ package {name} is defined in two different locations:\n\
         key: WorldKey,
         id: InterfaceId,
         stability: &Stability,
+        implements: Option<InterfaceId>,
     ) {
         if imports.contains_key(&key) {
             return;
         }
         for dep in self.interface_direct_deps(id) {
-            self.elaborate_world_import(imports, WorldKey::Interface(dep), dep, stability);
+            self.elaborate_world_import(imports, WorldKey::Interface(dep), dep, stability, None);
         }
         let prev = imports.insert(
             key,
             WorldItem::Interface {
                 id,
                 stability: stability.clone(),
+                implements,
                 span: Default::default(),
             },
         );
@@ -2072,23 +2139,25 @@ package {name} is defined in two different locations:\n\
     /// operation fails.
     fn elaborate_world_exports(
         &self,
-        export_interfaces: &IndexMap<InterfaceId, (WorldKey, &Stability)>,
+        export_interfaces: &[(InterfaceId, WorldKey, &Stability, Option<InterfaceId>)],
+        export_interface_ids: &HashSet<InterfaceId>,
         imports: &mut IndexMap<WorldKey, WorldItem>,
         exports: &mut IndexMap<WorldKey, WorldItem>,
     ) -> Result<()> {
         let mut required_imports = HashSet::new();
-        for (id, (key, stability)) in export_interfaces.iter() {
+        for (id, key, stability, implements) in export_interfaces.iter() {
             let name = self.name_world_key(&key);
             let ok = add_world_export(
                 self,
                 imports,
                 exports,
-                export_interfaces,
+                export_interface_ids,
                 &mut required_imports,
                 *id,
                 key,
                 true,
                 stability,
+                *implements,
             );
             if !ok {
                 bail!(
@@ -2119,12 +2188,13 @@ package {name} is defined in two different locations:\n\
             resolve: &Resolve,
             imports: &mut IndexMap<WorldKey, WorldItem>,
             exports: &mut IndexMap<WorldKey, WorldItem>,
-            export_interfaces: &IndexMap<InterfaceId, (WorldKey, &Stability)>,
+            export_interface_ids: &HashSet<InterfaceId>,
             required_imports: &mut HashSet<InterfaceId>,
             id: InterfaceId,
             key: &WorldKey,
             add_export: bool,
             stability: &Stability,
+            implements: Option<InterfaceId>,
         ) -> bool {
             if exports.contains_key(key) {
                 if add_export {
@@ -2140,17 +2210,18 @@ package {name} is defined in two different locations:\n\
             }
             let ok = resolve.interface_direct_deps(id).all(|dep| {
                 let key = WorldKey::Interface(dep);
-                let add_export = add_export && export_interfaces.contains_key(&dep);
+                let add_export = add_export && export_interface_ids.contains(&dep);
                 add_world_export(
                     resolve,
                     imports,
                     exports,
-                    export_interfaces,
+                    export_interface_ids,
                     required_imports,
                     dep,
                     &key,
                     add_export,
                     stability,
+                    None,
                 )
             });
             if !ok {
@@ -2159,6 +2230,7 @@ package {name} is defined in two different locations:\n\
             let item = WorldItem::Interface {
                 id,
                 stability: stability.clone(),
+                implements,
                 span: Default::default(),
             };
             if add_export {
@@ -2252,11 +2324,13 @@ package {name} is defined in two different locations:\n\
                 &WorldItem::Interface {
                     id: *to_replace,
                     stability: Default::default(),
+                    implements: None,
                     span: Default::default(),
                 },
                 &WorldItem::Interface {
                     id: *replace_with,
                     stability: Default::default(),
+                    implements: None,
                     span: Default::default(),
                 },
             )
@@ -3499,8 +3573,11 @@ impl Remap {
             }
             self.update_world_key(&mut name, span)?;
             match &mut item {
-                WorldItem::Interface { id, .. } => {
+                WorldItem::Interface { id, implements, .. } => {
                     *id = self.map_interface(*id, span)?;
+                    if let Some(imp) = implements {
+                        *imp = self.map_interface(*imp, span)?;
+                    }
                 }
                 WorldItem::Function(f) => {
                     self.update_function(resolve, f, span)?;
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-conflicts-func.wit b/crates/wit-parser/tests/ui/parse-fail/implements-conflicts-func.wit
new file mode 100644
index 0000000000..64f4fc1757
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-conflicts-func.wit
@@ -0,0 +1,11 @@
+// parse-fail
+package foo:foo;
+
+interface store {
+  get: func() -> option<string>;
+}
+
+world test {
+  import primary: func();
+  import primary: store;
+}
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-conflicts-func.wit.result b/crates/wit-parser/tests/ui/parse-fail/implements-conflicts-func.wit.result
new file mode 100644
index 0000000000..dbfa3bb0d2
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-conflicts-func.wit.result
@@ -0,0 +1,5 @@
+import `primary` conflicts with prior func of same name
+     --> tests/ui/parse-fail/implements-conflicts-func.wit:10:10
+      |
+   10 |   import primary: store;
+      |          ^------
\ No newline at end of file
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-duplicate-label.wit b/crates/wit-parser/tests/ui/parse-fail/implements-duplicate-label.wit
new file mode 100644
index 0000000000..68f4e45742
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-duplicate-label.wit
@@ -0,0 +1,11 @@
+// parse-fail
+package foo:foo;
+
+interface store {
+  get: func() -> option<string>;
+}
+
+world test {
+  import primary: store;
+  import primary: store;
+}
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-duplicate-label.wit.result b/crates/wit-parser/tests/ui/parse-fail/implements-duplicate-label.wit.result
new file mode 100644
index 0000000000..72af579bb3
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-duplicate-label.wit.result
@@ -0,0 +1,5 @@
+import `primary` conflicts with prior interface of same name
+     --> tests/ui/parse-fail/implements-duplicate-label.wit:10:10
+      |
+   10 |   import primary: store;
+      |          ^------
\ No newline at end of file
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-nonexistent.wit b/crates/wit-parser/tests/ui/parse-fail/implements-nonexistent.wit
new file mode 100644
index 0000000000..30cbfce02c
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-nonexistent.wit
@@ -0,0 +1,10 @@
+// parse-fail
+package foo:foo;
+
+interface store {
+  get: func() -> option<string>;
+}
+
+world test {
+  import primary: nonexistent;
+}
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-nonexistent.wit.result b/crates/wit-parser/tests/ui/parse-fail/implements-nonexistent.wit.result
new file mode 100644
index 0000000000..3a332c6883
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-nonexistent.wit.result
@@ -0,0 +1,5 @@
+interface or world `nonexistent` does not exist
+     --> tests/ui/parse-fail/implements-nonexistent.wit:9:19
+      |
+    9 |   import primary: nonexistent;
+      |                   ^----------
\ No newline at end of file
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-not-interface.wit b/crates/wit-parser/tests/ui/parse-fail/implements-not-interface.wit
new file mode 100644
index 0000000000..c0a070c7fb
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-not-interface.wit
@@ -0,0 +1,6 @@
+// parse-fail
+package foo:foo;
+
+world test {
+  import primary: test;
+}
diff --git a/crates/wit-parser/tests/ui/parse-fail/implements-not-interface.wit.result b/crates/wit-parser/tests/ui/parse-fail/implements-not-interface.wit.result
new file mode 100644
index 0000000000..95b62fabf9
--- /dev/null
+++ b/crates/wit-parser/tests/ui/parse-fail/implements-not-interface.wit.result
@@ -0,0 +1,5 @@
+name `test` is defined as a world, not an interface
+     --> tests/ui/parse-fail/implements-not-interface.wit:5:19
+      |
+    5 |   import primary: test;
+      |                   ^---
\ No newline at end of file
diff --git a/crates/wit-smith/src/config.rs b/crates/wit-smith/src/config.rs
index e5d0849845..ba0ec2074f 100644
--- a/crates/wit-smith/src/config.rs
+++ b/crates/wit-smith/src/config.rs
@@ -31,6 +31,8 @@ pub struct Config {
     pub fixed_length_lists: bool,
     #[cfg_attr(feature = "clap", clap(long, default_value_t = Config::default().world_include))]
     pub world_include: bool,
+    #[cfg_attr(feature = "clap", clap(long, default_value_t = Config::default().implements))]
+    pub implements: bool,
 }
 
 impl Default for Config {
@@ -50,6 +52,7 @@ impl Default for Config {
             error_context: false,
             fixed_length_lists: false,
             world_include: false,
+            implements: false,
         }
     }
 }
@@ -71,6 +74,7 @@ impl Arbitrary<'_> for Config {
             error_context: u.arbitrary()?,
             fixed_length_lists: u.arbitrary()?,
             world_include: false,
+            implements: u.arbitrary()?,
         })
     }
 }
diff --git a/crates/wit-smith/src/generate.rs b/crates/wit-smith/src/generate.rs
index eddc657303..461c8672c7 100644
--- a/crates/wit-smith/src/generate.rs
+++ b/crates/wit-smith/src/generate.rs
@@ -647,6 +647,7 @@ impl<'a> InterfaceGenerator<'a> {
             Func(Direction),
             Interface(Direction),
             AnonInterface(Direction),
+            ImplementsInterface(Direction),
             Type,
             Use,
             Include,
@@ -666,9 +667,18 @@ impl<'a> InterfaceGenerator<'a> {
             && u.arbitrary()?
         {
             let kind = u.arbitrary::<ItemKind>()?;
+
+            // Gate config-disabled features early, before consuming any
+            // more random bytes, to keep byte consumption deterministic
+            // when a feature is toggled off.
+            if matches!(kind, ItemKind::ImplementsInterface(_)) && !self.generator.config.implements
+            {
+                continue;
+            }
+
             let (direction, named) = match kind {
                 ItemKind::Func(dir) | ItemKind::AnonInterface(dir) => (Some(dir), true),
-                ItemKind::Interface(dir) => (Some(dir), false),
+                ItemKind::Interface(dir) | ItemKind::ImplementsInterface(dir) => (Some(dir), false),
                 ItemKind::Type => (None, true),
                 ItemKind::Use => (None, false),
                 ItemKind::Include => (None, false),
@@ -750,6 +760,34 @@ impl<'a> InterfaceGenerator<'a> {
                     }
                     part.push_str(";");
                 }
+                ItemKind::ImplementsInterface(dir) => {
+                    let names = match dir {
+                        Direction::Import => &mut self.unique_names,
+                        Direction::Export => &mut export_names,
+                    };
+                    let label = gen_unique_name(u, names)?;
+
+                    let mut path_str = String::new();
+                    if self
+                        .generator
+                        .gen_interface_path(u, self.file, &mut path_str)?
+                        .is_none()
+                    {
+                        continue;
+                    }
+
+                    self.generator.packages.add_name(
+                        self.package_name.to_string(),
+                        world_name.to_string(),
+                        label.to_string(),
+                    );
+
+                    part.push_str("%");
+                    part.push_str(&label);
+                    part.push_str(": ");
+                    part.push_str(&path_str);
+                    part.push_str(";");
+                }
                 ItemKind::AnonInterface(_) => {
                     let iface =
                         InterfaceGenerator::new(self.generator, self.file, self.package_name, None)
diff --git a/crates/wit-smith/src/lib.rs b/crates/wit-smith/src/lib.rs
index ebc0e09fa2..22f4cb8179 100644
--- a/crates/wit-smith/src/lib.rs
+++ b/crates/wit-smith/src/lib.rs
@@ -55,5 +55,6 @@ pub fn smith(config: &Config, u: &mut Unstructured<'_>) -> Result<Vec<u8>> {
             return Err(arbitrary::Error::IncorrectFormat);
         }
     }
+
     Ok(wasm)
 }