A module consists of an otherwise normal ixml grammar, preceded by specifications of rules used from other modules and what is shared for use from this module.

A specification of what to use from another module lists the rules needed from each module it uses. Such a specification should be recognisable as different from an ixml rule.

The character to signal such a specification has been chosen as "+", though any character that doesn't start the first ixml rule in a grammar could have been used in the design; ixml rules can start with namestart characters, "-", "^" (and "@" but it is not possible to start the first rule of a grammar with that character):

+uses css from css.ixml

and

+uses iri, url, uri, urn from uri.ixml

This specifies which module to use, and which rules from that module are intended to be used.

It is possible to combine them

+uses css from css.ixml; iri, url, uri, urn from uri.ixml

The specification of what is allowable to be used from a module is similar:

+shares iri, url, uri, urn

There are two main choices for a grammar for these. The first literally recognises the structure as it is specified above:

module: s, (uses; shares)*, ixml.
           uses: -"+uses", rs, from++(-";", s).
         shares: -"+shares", rs, entries.
           from: entries, rs, -"from", rs, location, s.
       -entries: share++(-",", s).
          share: @name, s.
        @source: iri.

where s is the regular ixml rule for optional whitespace, rs for required whitespace, name the rule for a rule name, ixml the rule for an ixml grammar, and iri, not defined here, representing an internationalised URI [iri], allowing the use of grammars from external sources, such as:

+uses iri from https://example.com/ixml/modules/iri.ixml

For a specification like

+uses css from css.ixml; iri, url, uri, urn from uri.ixml

this produces a resulting structure like

<uses>
            <from source='css.ixml'>
               <share name='css'/>
            </from>
            <from source='iri.ixml'>
               <share name='iri'/>
               <share name='url'/>
               <share name='uri'/>
               <share name='urn'/>
            </from>
         </uses>

Alternatively, the grammar could look like:

module: s, (multiuse; shares)*, ixml.
         -multiuse: -"+uses", rs, uses++(-";", s).
            shares: -"+shares", rs, entries.
              uses: entries, rs, -"from", rs, from.
          -entries: share++(-",", s).
             share: @name, s.
             @from: iri, s.

where the resulting structure then looks like:

<uses from='css.ixml'>
            <share name='css'/>
         </uses>
         <uses from='uri.ixml'>
            <share name='iri'/>
            <share name='url'/>
            <share name='uri'/>
            <share name='urn'/>
         </uses>

The advantage of the latter version is that processing is slightly easier, since shallower, with a slight disadvantage with respect to round-tripping, since the two forms

+uses css from css.ixml; iri, url, uri, urn from uri.ixml

and

+uses css from css.ixml
         +uses iri, url, uri, urn from uri.ixml

are no longer distinguishable on roundtripping, since they produce the same serialisation.