diff --git a/std/complex.d b/std/complex.d
@@ -108,10 +108,10 @@ struct Complex(T)  if (isFloatingPoint!T)
     /** Converts the complex number to a string representation.
 
     The second form of this function is usually not called directly;
-    instead, it is used via $(XREF string,format), as shown in the examples
+    instead, it is used via $(REF format, std,string), as shown in the examples
     below.  Supported format characters are 'e', 'f', 'g', 'a', and 's'.
 
-    See the $(MREF std, format) and $(XREF string, format)
+    See the $(MREF std, format) and $(REF format, std,string)
     documentation for more information.
     */
     string toString() const /* TODO: @safe pure nothrow */
@@ -822,7 +822,7 @@ unittest{
 
     Note:
     $(D expi) is included here for convenience and for easy migration of code
-    that uses $(XREF math,_expi).  Unlike $(XREF math,_expi), which uses the
+    that uses $(REF _expi, std,math).  Unlike $(REF _expi, std,math), which uses the
     x87 $(I fsincos) instruction when possible, this function is no faster
     than calculating cos(y) and sin(y) separately.
 */

diff --git a/std/concurrency.d b/std/concurrency.d
@@ -259,7 +259,7 @@ class LinkTerminated : Exception
 
 /**
  * Thrown if a message was sent to a thread via
- * $(XREF concurrency, prioritySend) and the receiver does not have a handler
+ * $(REF prioritySend, std,concurrency) and the receiver does not have a handler
  * for a message of this type.
  */
 class PriorityMessageException : Exception
@@ -596,7 +596,7 @@ unittest
  * Places the values as a message at the back of tid's message queue.
  *
  * Sends the supplied value to the thread represented by tid.  As with
- * $(XREF concurrency, spawn), $(D T) must not have unshared aliasing.
+ * $(REF spawn, std,concurrency), $(D T) must not have unshared aliasing.
  */
 void send(T...)( Tid tid, T vals )
 {
@@ -648,10 +648,10 @@ private void _send(T...)( MsgType type, Tid tid, T vals )
  * specified types are available.  This function works by pattern matching
  * a message against a set of delegates and executing the first match found.
  *
- * If a delegate that accepts a $(XREF variant, Variant) is included as
+ * If a delegate that accepts a $(REF Variant, std,variant) is included as
  * the last argument to $(D receive), it will match any message that was not
  * matched by an earlier delegate.  If more than one argument is sent,
- * the $(D Variant) will contain a $(XREF typecons, Tuple) of all values
+ * the $(D Variant) will contain a $(REF Tuple, std,typecons) of all values
  * sent.
  *
  * Example:
@@ -740,7 +740,7 @@ private template receiveOnlyRet(T...)
  *          is received.
  *
  * Returns: The received message.  If $(D T.length) is greater than one,
- *          the message will be packed into a $(XREF typecons, Tuple).
+ *          the message will be packed into a $(REF Tuple, std,typecons).
  *
  * Example:
  * ---

diff --git a/std/container/rbtree.d b/std/container/rbtree.d
@@ -722,7 +722,7 @@ private struct RBRange(N)
  * of $(BIGOH lg(n)).
  *
  * To use a different comparison than $(D "a < b"), pass a different operator string
- * that can be used by $(XREF functional, binaryFun), or pass in a
+ * that can be used by $(REF binaryFun, std,functional), or pass in a
  * function, delegate, functor, or any type where $(D less(a, b)) results in a $(D bool)
  * value.
  *

diff --git a/std/conv.d b/std/conv.d
@@ -5204,7 +5204,7 @@ unittest
     (e.g from $(D int) to $(D long)).
 
     Note that the result is always mutable even if the original type was const
-    or immutable. In order to retain the constness, use $(XREF traits, Unsigned).
+    or immutable. In order to retain the constness, use $(REF Unsigned, std,traits).
  */
 auto unsigned(T)(T x) if (isIntegral!T)
 {
@@ -5278,7 +5278,7 @@ unittest
     (e.g from $(D uint) to $(D ulong)).
 
     Note that the result is always mutable even if the original type was const
-    or immutable. In order to retain the constness, use $(XREF traits, Signed).
+    or immutable. In order to retain the constness, use $(REF Signed, std,traits).
  */
 auto signed(T)(T x) if (isIntegral!T)
 {

diff --git a/std/digest/digest.d b/std/digest/digest.d
@@ -388,7 +388,7 @@ unittest
 
 /**
  * Checks whether the digest has a $(D blockSize) member, which contains the
- * digest's internal block size in bits. It is primarily used by $(XREF digest.hmac, HMAC).
+ * digest's internal block size in bits. It is primarily used by $(REF HMAC, std,digest.hmac).
  */
 
 template hasBlockSize(T)

diff --git a/std/digest/hmac.d b/std/digest/hmac.d
@@ -26,7 +26,7 @@ import std.meta : allSatisfy;
  * information about the block size, it can be supplied explicitly using
  * the second overload.
  *
- * This type conforms to $(XREF digest.digest, isDigest).
+ * This type conforms to $(REF isDigest, std,digest.digest).
  */
 
 version(StdDdoc)
@@ -142,7 +142,7 @@ if (hashBlockSize % 8 == 0)
 
     /**
      * Feeds a piece of data into the hash computation. This method allows the
-     * type to be used as an $(XREF range, OutputRange).
+     * type to be used as an $(REF OutputRange, std,range).
      *
      * Returns:
      * A reference to the digest for convenient chaining.

diff --git a/std/encoding.d b/std/encoding.d
@@ -2197,7 +2197,7 @@ unittest
     r = Destination string
 
  See_Also:
-    $(XREF conv, to)
+    $(REF to, std,conv)
  */
 void transcode(Src,Dst)(immutable(Src)[] s,out immutable(Dst)[] r)
 in

diff --git a/std/exception.d b/std/exception.d
@@ -1748,7 +1748,7 @@ Returns: A wrapper $(D struct) that preserves the range interface of $(D input).
 
 opSlice:
 Infinite ranges with slicing support must return an instance of
-$(XREF range, Take) when sliced with a specific lower and upper
+$(REF Take, std,range) when sliced with a specific lower and upper
 bound (see $(XREF_PACK range,primitives,hasSlicing)); $(D handle) deals with
 this by $(D take)ing 0 from the return value of the handler function and
 returning that when an exception is caught.

diff --git a/std/file.d b/std/file.d
@@ -382,7 +382,7 @@ version (linux) @safe unittest
 }
 
 /********************************************
-Read and validates (using $(XREF utf, validate)) a text file. $(D S)
+Read and validates (using $(REF validate, std,utf)) a text file. $(D S)
 can be a type of array of characters of any width and constancy. No
 width conversion is performed; if the width of the characters in file
 $(D name) is different from the width of elements of $(D S),
@@ -442,7 +442,7 @@ Params:
 
 Throws: $(D FileException) on error.
 
-See_also: $(XREF stdio,toFile)
+See_also: $(REF toFile, std,stdio)
  */
 void write(R)(R name, const void[] buffer)
     if ((isInputRange!R && isSomeChar!(ElementEncodingType!R) || isSomeString!R) &&
@@ -2566,7 +2566,7 @@ else version (NetBSD)
  * Returns the full path of the current executable.
  *
  * Throws:
- * $(XREF object, Exception)
+ * $(REF Exception, std,object)
  */
 @trusted string thisExePath ()
 {
@@ -3903,7 +3903,7 @@ unittest
         path = The directory to iterate over.
         pattern  = String with wildcards, such as $(RED "*.d"). The supported
                    wildcard strings are described under
-                   $(XREF _path, globMatch).
+                   $(REF globMatch, std,_path).
         mode = Whether the directory's sub-directories should be iterated
                over depth-first ($(D_PARAM depth)), breadth-first
                ($(D_PARAM breadth)), or not at all ($(D_PARAM shallow)).

diff --git a/std/format.d b/std/format.d
@@ -131,7 +131,7 @@ private alias enforceFmt = enforceEx!FormatException;
    Params:
 
    w = Output is sent to this writer. Typical output writers include
-   $(XREF array,Appender!string) and $(XREF stdio,LockingTextWriter).
+   $(REF Appender!string, std,array) and $(REF LockingTextWriter, std,stdio).
 
    fmt = Format string.
 
@@ -6415,7 +6415,7 @@ unittest
 /*****************************************************
  * Format arguments into a string.
  *
- * Params: fmt  = Format string. For detailed specification, see $(XREF _format,formattedWrite).
+ * Params: fmt  = Format string. For detailed specification, see $(REF formattedWrite, std,_format).
  *         args = Variadic list of arguments to format into returned string.
  */
 immutable(Char)[] format(Char, Args...)(in Char[] fmt, Args args) if (isSomeChar!Char)

diff --git a/std/functional.d b/std/functional.d
@@ -784,7 +784,7 @@ unittest
 
 /**
 Takes multiple functions and adjoins them together. The result is a
-$(XREF typecons, Tuple) with one element per passed-in function. Upon
+$(REF Tuple, std,typecons) with one element per passed-in function. Upon
 invocation, the returned tuple is the adjoined results of all
 functions.
 

diff --git a/std/json.d b/std/json.d
@@ -700,7 +700,7 @@ struct JSONValue
 
 /**
 Parses a serialized string and returns a tree of JSON values.
-Throws: $(XREF json,JSONException) if the depth exceeds the max depth.
+Throws: $(REF JSONException, std,json) if the depth exceeds the max depth.
 Params:
     json = json-formatted string to parse
     maxDepth = maximum depth of nesting allowed, -1 disables depth checking
@@ -1068,7 +1068,7 @@ unittest
 
 /**
 Parses a serialized string and returns a tree of JSON values.
-Throws: $(XREF json,JSONException) if the depth exceeds the max depth.
+Throws: $(REF JSONException, std,json) if the depth exceeds the max depth.
 Params:
     json = json-formatted string to parse
     options = enable decoding string representations of NaN/Inf as float values

diff --git a/std/net/curl.d b/std/net/curl.d
@@ -1975,7 +1975,7 @@ private mixin template Protocol()
      * theprotocol.netInterface = [ 192, 168, 1, 32 ];
      * ----
      *
-     * See: $(XREF socket, InternetAddress)
+     * See: $(REF InternetAddress, std,socket)
      */
     @property void netInterface(const(char)[] i)
     {
@@ -2628,7 +2628,7 @@ struct HTTP
          * theprotocol.netInterface = [ 192, 168, 1, 32 ];
          * ----
          *
-         * See: $(XREF socket, InternetAddress)
+         * See: $(REF InternetAddress, std,socket)
          */
         @property void netInterface(const(char)[] i);
 
@@ -3308,7 +3308,7 @@ struct FTP
          * theprotocol.netInterface = [ 192, 168, 1, 32 ];
          * ----
          *
-         * See: $(XREF socket, InternetAddress)
+         * See: $(REF InternetAddress, std,socket)
          */
         @property void netInterface(const(char)[] i);
 
@@ -3657,7 +3657,7 @@ struct SMTP
          * theprotocol.netInterface = [ 192, 168, 1, 32 ];
          * ----
          *
-         * See: $(XREF socket, InternetAddress)
+         * See: $(REF InternetAddress, std,socket)
          */
         @property void netInterface(const(char)[] i);
 

diff --git a/std/numeric.d b/std/numeric.d
@@ -1413,7 +1413,7 @@ than that for a Fibonacci search.
 References:
     "Algorithms for Minimization without Derivatives", Richard Brent, Prentice-Hall, Inc. (1973)
 
-See_Also: $(LREF findRoot), $(XREF math, isNormal)
+See_Also: $(LREF findRoot), $(REF isNormal, std,math)
 +/
 Tuple!(T, "x", Unqual!(ReturnType!DF), "y", T, "error")
 findLocalMin(T, DF)(

diff --git a/std/outbuffer.d b/std/outbuffer.d
@@ -322,12 +322,12 @@ class OutBuffer
      * Formats and writes its arguments in text format to the OutBuffer.
      *
      * Params:
-     *  fmt = format string as described in $(XREF format, formattedWrite)
+     *  fmt = format string as described in $(REF formattedWrite, std,format)
      *  args = arguments to be formatted
      *
      * See_Also:
-     *  $(XREF stdio, _writef);
-     *  $(XREF format, formattedWrite);
+     *  $(REF _writef, std,stdio);
+     *  $(REF formattedWrite, std,format);
      */
     void writef(Char, A...)(in Char[] fmt, A args)
     {
@@ -348,12 +348,12 @@ class OutBuffer
      * followed by a newline.
      *
      * Params:
-     *  fmt = format string as described in $(XREF format, formattedWrite)
+     *  fmt = format string as described in $(REF formattedWrite, std,format)
      *  args = arguments to be formatted
      *
      * See_Also:
-     *  $(XREF stdio, _writefln);
-     *  $(XREF format, formattedWrite);
+     *  $(REF _writefln, std,stdio);
+     *  $(REF formattedWrite, std,format);
      */
     void writefln(Char, A...)(in Char[] fmt, A args)
     {

diff --git a/std/parallelism.d b/std/parallelism.d
@@ -414,7 +414,7 @@ meaning that any memory writes made in the thread that executed the $(D Task)
 are guaranteed to be visible in the calling thread after one of these functions
 returns.
 
-The $(XREF parallelism, task) and $(XREF parallelism, scopedTask) functions can
+The $(REF task, std,parallelism) and $(REF scopedTask, std,parallelism) functions can
 be used to create an instance of this struct.  See $(D task) for usage examples.
 
 Function results are returned from $(D yieldForce), $(D spinForce) and
@@ -733,7 +733,7 @@ struct Task(alias fun, Args...)
     newly created thread, then terminate the thread.  This can be used for
     future/promise parallelism.  An explicit priority may be given
     to the $(D Task).  If one is provided, its value is forwarded to
-    $(D core.thread.Thread.priority). See $(XREF parallelism, task) for
+    $(D core.thread.Thread.priority). See $(REF task, std,parallelism) for
     usage example.
     */
     void executeInNewThread() @trusted
@@ -771,8 +771,8 @@ ReturnType!F run(F, Args...)(F fpOrDelegate, ref Args args)
 /**
 Creates a $(D Task) on the GC heap that calls an alias.  This may be executed
 via $(D Task.executeInNewThread) or by submitting to a
-$(XREF parallelism, TaskPool).  A globally accessible instance of
-$(D TaskPool) is provided by $(XREF parallelism, taskPool).
+$(REF TaskPool, std,parallelism).  A globally accessible instance of
+$(D TaskPool) is provided by $(REF taskPool, std,parallelism).
 
 Returns:  A pointer to the $(D Task).
 
@@ -883,7 +883,7 @@ identical to the non-@safe case, but safety introduces some restrictions:
 1.  $(D fun) must be @safe or @trusted.
 
 2.  $(D F) must not have any unshared aliasing as defined by
-    $(XREF traits, hasUnsharedAliasing).  This means it
+    $(REF hasUnsharedAliasing, std,traits).  This means it
     may not be an unshared delegate or a non-shared class or struct
     with overloaded $(D opCall).  This also precludes accepting template
     alias parameters.
@@ -1000,7 +1000,7 @@ thread that executes the $(D Task) at the front of the queue when one is
 available and sleeps when the queue is empty.
 
 This class should usually be used via the global instantiation
-available via the $(XREF parallelism, taskPool) property.
+available via the $(REF taskPool, std,parallelism) property.
 Occasionally it is useful to explicitly instantiate a $(D TaskPool):
 
 1.  When you want $(D TaskPool) instances with multiple priorities, for example
@@ -3141,7 +3141,7 @@ public:
     Notes:
 
     @trusted overloads of this function are called for $(D Task)s if
-    $(XREF traits, hasUnsharedAliasing) is false for the $(D Task)'s
+    $(REF hasUnsharedAliasing, std,traits) is false for the $(D Task)'s
     return type or the function the $(D Task) executes is $(D pure).
     $(D Task) objects that meet all other requirements specified in the
     $(D @trusted) overloads of $(D task) and $(D scopedTask) may be created

diff --git a/std/path.d b/std/path.d
@@ -10,8 +10,8 @@
     between a _path that points to a directory and a _path that points to a
     file, and it does not know whether or not the object pointed to by the
     _path actually exists in the file system.
-    To differentiate between these cases, use $(XREF file,isDir) and
-    $(XREF file,exists).
+    To differentiate between these cases, use $(REF isDir, std,file) and
+    $(REF exists, std,file).
 
     Note that on Windows, both the backslash ($(D `\`)) and the slash ($(D `/`))
     are in principle valid directory separators.  This module treats them
@@ -3547,7 +3547,7 @@ unittest
     or is equal to $(D ".") or $(D "..").
 
     $(B It does $(I not) check whether the _path points to an existing file
-    or directory; use $(XREF file,exists) for this purpose.)
+    or directory; use $(REF exists, std,file) for this purpose.)
 
     On Windows, some special rules apply:
     $(UL

diff --git a/std/process.d b/std/process.d
@@ -225,7 +225,7 @@ wait(spawnProcess("myapp", ["foo" : "bar"], Config.newEnv));
 
 Standard_streams:
 The optional arguments $(D stdin), $(D stdout) and $(D stderr) may
-be used to assign arbitrary $(XREF stdio,File) objects as the standard
+be used to assign arbitrary $(REF File, std,stdio) objects as the standard
 input, output and error streams, respectively, of the child process.  The
 former must be opened for reading, while the latter two must be opened for
 writing.  The default is for the child process to inherit the standard
@@ -260,14 +260,14 @@ Params:
 args    = An array which contains the program name as the zeroth element
           and any command-line arguments in the following elements.
 stdin   = The standard input stream of the child process.
-          This can be any $(XREF stdio,File) that is opened for reading.
+          This can be any $(REF File, std,stdio) that is opened for reading.
           By default the child process inherits the parent's input
           stream.
 stdout  = The standard output stream of the child process.
-          This can be any $(XREF stdio,File) that is opened for writing.
+          This can be any $(REF File, std,stdio) that is opened for writing.
           By default the child process inherits the parent's output stream.
 stderr  = The standard error stream of the child process.
-          This can be any $(XREF stdio,File) that is opened for writing.
+          This can be any $(REF File, std,stdio) that is opened for writing.
           By default the child process inherits the parent's error stream.
 env     = Additional environment variables for the child process.
 config  = Flags that control process creation. See $(LREF Config)
@@ -281,7 +281,7 @@ A $(LREF Pid) object that corresponds to the spawned process.
 
 Throws:
 $(LREF ProcessException) on failure to start the process.$(BR)
-$(XREF stdio,StdioException) on failure to pass one of the streams
+$(REF StdioException, std,stdio) on failure to pass one of the streams
     to the child process (Windows only).$(BR)
 $(CXREF exception,RangeError) if $(D args) is empty.
 */
@@ -1588,7 +1588,7 @@ Returns:
 A $(LREF Pipe) object that corresponds to the created _pipe.
 
 Throws:
-$(XREF stdio,StdioException) on failure.
+$(REF StdioException, std,stdio) on failure.
 */
 version (Posix)
 Pipe pipe() @trusted //TODO: @safe
@@ -1655,7 +1655,7 @@ struct Pipe
     /**
     Closes both ends of the pipe.
 
-    Normally it is not necessary to do this manually, as $(XREF stdio,File)
+    Normally it is not necessary to do this manually, as $(REF File, std,stdio)
     objects are automatically closed when there are no more references
     to them.
 
@@ -1664,7 +1664,7 @@ struct Pipe
     child process is platform dependent.)
 
     Throws:
-    $(XREF exception,ErrnoException) if an error occurs.
+    $(REF ErrnoException, std,exception) if an error occurs.
     */
     void close() @safe
     {
@@ -1729,14 +1729,14 @@ shellPath = The path to the shell to use to run the specified program.
             By default this is $(LREF nativeShell).
 
 Returns:
-A $(LREF ProcessPipes) object which contains $(XREF stdio,File)
+A $(LREF ProcessPipes) object which contains $(REF File, std,stdio)
 handles that communicate with the redirected streams of the child
 process, along with a $(LREF Pid) object that corresponds to the
 spawned process.
 
 Throws:
 $(LREF ProcessException) on failure to start the process.$(BR)
-$(XREF stdio,StdioException) on failure to redirect any of the streams.$(BR)
+$(REF StdioException, std,stdio) on failure to redirect any of the streams.$(BR)
 
 Example:
 ---
@@ -2000,7 +2000,7 @@ unittest
 }
 
 /**
-Object which contains $(XREF stdio,File) handles that allow communication
+Object which contains $(REF File, std,stdio) handles that allow communication
 with a child process through its standard streams.
 */
 struct ProcessPipes
@@ -2013,7 +2013,7 @@ struct ProcessPipes
     }
 
     /**
-    An $(XREF stdio,File) that allows writing to the child process'
+    An $(REF File, std,stdio) that allows writing to the child process'
     standard input stream.
 
     Throws:
@@ -2029,7 +2029,7 @@ struct ProcessPipes
     }
 
     /**
-    An $(XREF stdio,File) that allows reading from the child process'
+    An $(REF File, std,stdio) that allows reading from the child process'
     standard output stream.
 
     Throws:
@@ -2045,7 +2045,7 @@ struct ProcessPipes
     }
 
     /**
-    An $(XREF stdio,File) that allows reading from the child process'
+    An $(REF File, std,stdio) that allows reading from the child process'
     standard error stream.
 
     Throws:
@@ -2122,7 +2122,7 @@ value is the signal number.  (See $(LREF wait) for details.)
 
 Throws:
 $(LREF ProcessException) on failure to start the process.$(BR)
-$(XREF stdio,StdioException) on failure to capture output.
+$(REF StdioException, std,stdio) on failure to capture output.
 */
 auto execute(in char[][] args,
              const string[string] env = null,
@@ -2981,7 +2981,7 @@ static:
 
     Throws:
     $(OBJECTREF Exception) if the environment variable does not exist,
-    or $(XREF utf,UTFException) if the variable contains invalid UTF-16
+    or $(REF UTFException, std,utf) if the variable contains invalid UTF-16
     characters (Windows only).
 
     See_also:
@@ -3016,7 +3016,7 @@ static:
     ---
 
     Throws:
-    $(XREF utf,UTFException) if the variable contains invalid UTF-16
+    $(REF UTFException, std,utf) if the variable contains invalid UTF-16
     characters (Windows only).
     */
     string get(in char[] name, string defaultValue = null) @safe

diff --git a/std/range/package.d b/std/range/package.d
@@ -2967,7 +2967,7 @@ Take!(Repeat!T) repeat(T)(T value, size_t n)
 }
 
 /**
-Given callable ($(XREF traits, isCallable)) $(D fun), create as a range
+Given callable ($(REF isCallable, std,traits)) $(D fun), create as a range
 whose front is defined by successive calls to $(D fun()).
 This is especially useful to call function with global side effects (random
 functions), or to create ranges expressed as a single delegate, rather than
@@ -2981,7 +2981,7 @@ The resulting range will call $(D fun()) on every call to $(D front),
 and only when $(D front) is called, regardless of how the range is
 iterated.
 It is advised to compose generate with either
-$(XREF_PACK algorithm,iteration,cache) or $(XREF array,array), or to use it in a
+$(XREF_PACK algorithm,iteration,cache) or $(REF array, std,array), or to use it in a
 foreach loop.
 A by-value foreach loop means that the loop value is not $(D ref).
 
@@ -5370,7 +5370,7 @@ auto iota(B, E)(B begin, E end)
 }
 
 /**
-User-defined types such as $(XREF bigint, BigInt) are also supported, as long
+User-defined types such as $(REF BigInt, std,bigint) are also supported, as long
 as they can be incremented with $(D ++) and compared with $(D <) or $(D ==).
 */
 // Issue 6447
@@ -7274,7 +7274,7 @@ unittest
 /**
 Iterate over $(D range) with an attached index variable.
 
-Each element is a $(XREF typecons, Tuple) containing the index
+Each element is a $(REF Tuple, std,typecons) containing the index
 and the element, in that order, where the index member is named $(D index)
 and the element member is named $(D value).
 
@@ -9222,7 +9222,7 @@ struct NullSink
   It is important to note that as the resultant range is evaluated lazily,
   in the case of the version of $(D tee) that takes a function, the function
   will not actually be executed until the range is "walked" using functions
-  that evaluate ranges, such as $(XREF array,array) or
+  that evaluate ranges, such as $(REF array, std,array) or
   $(XREF_PACK algorithm,iteration,fold).
 
   Params:

diff --git a/std/stdio.d b/std/stdio.d
@@ -1480,7 +1480,7 @@ Params:
 buf = Buffer used to store the resulting line data. buf is
 resized as necessary.
 terminator = Line terminator (by default, $(D '\n')). Use
-$(XREF ascii, newline) for portability (unless the file was opened in
+$(REF newline, std,ascii) for portability (unless the file was opened in
 text mode).
 
 Returns:
@@ -1668,7 +1668,7 @@ is recommended if you want to process a complete file.
     /**
      * Read data from the file according to the specified
      * $(LINK2 std_format.html#_format-string, format specifier) using
-     * $(XREF _format,formattedRead).
+     * $(REF formattedRead, std,_format).
      */
     uint readf(Data...)(in char[] format, Data data)
     {
@@ -1899,7 +1899,7 @@ Char = Character type for each line, defaulting to $(D char).
 keepTerminator = Use $(D KeepTerminator.yes) to include the
 terminator at the end of each line.
 terminator = Line separator ($(D '\n') by default). Use
-$(XREF ascii, newline) for portability (unless the file was opened in
+$(REF newline, std,ascii) for portability (unless the file was opened in
 text mode).
 
 Example:
@@ -2058,7 +2058,7 @@ Char = Character type for each line, defaulting to $(D immutable char).
 keepTerminator = Use $(D KeepTerminator.yes) to include the
 terminator at the end of each line.
 terminator = Line separator ($(D '\n') by default). Use
-$(XREF ascii, newline) for portability (unless the file was opened in
+$(REF newline, std,ascii) for portability (unless the file was opened in
 text mode).
 
 Example:
@@ -2076,7 +2076,7 @@ void main()
 }
 ----
 See_Also:
-$(XREF file,readText)
+$(REF readText, std,file)
 */
     auto byLineCopy(Terminator = char, Char = immutable char)
             (KeepTerminator keepTerminator = KeepTerminator.no,
@@ -3568,7 +3568,7 @@ unittest
 /**
  * Read data from $(D stdin) according to the specified
  * $(LINK2 std_format.html#format-string, format specifier) using
- * $(XREF format,formattedRead).
+ * $(REF formattedRead, std,format).
  */
 uint readf(A...)(in char[] format, A args)
 {
@@ -3632,7 +3632,7 @@ if (isSomeString!S)
  *        $(D size_t) 0 for end of file, otherwise number of characters read
  * Params:
  *        buf = Buffer used to store the resulting line data. buf is resized as necessary.
- *        terminator = Line terminator (by default, $(D '\n')). Use $(XREF ascii, newline)
+ *        terminator = Line terminator (by default, $(D '\n')). Use $(REF newline, std,ascii)
  *        for portability (unless the file was opened in text mode).
  * Throws:
  *        $(D StdioException) on I/O error, or $(D UnicodeException) on Unicode conversion error.
@@ -4173,7 +4173,7 @@ unittest
 /**
 Writes an array or range to a file.
 Shorthand for $(D data.copy(File(fileName, "wb").lockingBinaryWriter)).
-Similar to $(XREF file,write), strings are written as-is,
+Similar to $(REF write, std,file), strings are written as-is,
 rather than encoded according to the $(D File)'s $(WEB
 en.cppreference.com/w/c/io#Narrow_and_wide_orientation,
 orientation).

diff --git a/std/string.d b/std/string.d
@@ -376,7 +376,7 @@ alias CaseSensitive = Flag!"caseSensitive";
 
     Throws:
         If the sequence starting at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
   +/
 ptrdiff_t indexOf(Range)(Range s, in dchar c,
@@ -699,7 +699,7 @@ unittest
 
     Throws:
         If the sequence starting at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
     Bugs:
         Does not work with case insensitive strings where the mapping of
@@ -971,7 +971,7 @@ unittest
 
     Throws:
         If the sequence ending at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
     $(D cs) indicates whether the comparisons are case sensitive.
   +/
@@ -1157,7 +1157,7 @@ ptrdiff_t lastIndexOf(Char)(const(Char)[] s, in dchar c, in size_t startIdx,
 
     Throws:
         If the sequence ending at $(D startIdx) does not represent a well
-        formed codepoint, then a $(XREF utf,UTFException) may be thrown.
+        formed codepoint, then a $(REF UTFException, std,utf) may be thrown.
 
     $(D cs) indicates whether the comparisons are case sensitive.
   +/
@@ -1538,7 +1538,7 @@ private ptrdiff_t indexOfAnyNeitherImpl(bool forward, bool any, Char, Char2)(
     then $(D -1) is returned. The $(D startIdx) slices $(D haystack) in the
     following way $(D haystack[startIdx .. $]). $(D startIdx) represents a
     codeunit index in $(D haystack). If the sequence ending at $(D startIdx)
-    does not represent a well formed codepoint, then a $(XREF utf,UTFException)
+    does not represent a well formed codepoint, then a $(REF UTFException, std,utf)
     may be thrown.
 
     Params:
@@ -1707,7 +1707,7 @@ ptrdiff_t indexOfAny(Char,Char2)(const(Char)[] haystack, const(Char2)[] needles,
     then $(D -1) is returned. The $(D stopIdx) slices $(D haystack) in the
     following way $(D s[0 .. stopIdx]). $(D stopIdx) represents a codeunit
     index in $(D haystack). If the sequence ending at $(D startIdx) does not
-    represent a well formed codepoint, then a $(XREF utf,UTFException) may be
+    represent a well formed codepoint, then a $(REF UTFException, std,utf) may be
     thrown.
 
     Params:
@@ -2281,7 +2281,7 @@ auto representation(Char)(Char[] s) @safe pure nothrow @nogc
  *     The capitalized string.
  *
  * See_Also:
- *      $(XREF uni, asCapitalized) for a lazy range version that doesn't allocate memory
+ *      $(REF asCapitalized, std,uni) for a lazy range version that doesn't allocate memory
  */
 S capitalize(S)(S input) @trusted pure
     if (isSomeString!S)
@@ -2350,8 +2350,8 @@ auto capitalize(S)(auto ref S s)
 
 /++
     Split $(D s) into an array of lines according to the unicode standard using
-    $(D '\r'), $(D '\n'), $(D "\r\n"), $(XREF uni, lineSep),
-    $(XREF uni, paraSep), $(D U+0085) (NEL), $(D '\v')  and $(D '\f')
+    $(D '\r'), $(D '\n'), $(D "\r\n"), $(REF lineSep, std,uni),
+    $(REF paraSep, std,uni), $(D U+0085) (NEL), $(D '\v')  and $(D '\f')
     as delimiters. If $(D keepTerm) is set to $(D KeepTerminator.yes), then the
     delimiter is included in the strings returned.
 
@@ -2371,8 +2371,8 @@ auto capitalize(S)(auto ref S s)
     array of strings, each element is a line that is a slice of $(D s)
   See_Also:
     $(LREF lineSplitter)
-    $(XREF algorithm, splitter)
-    $(XREF regex, splitter)
+    $(REF splitter, std,algorithm)
+    $(REF splitter, std,regex)
  +/
 alias KeepTerminator = Flag!"keepTerminator";
 
@@ -2679,7 +2679,7 @@ public:
 /***********************************
  *  Split an array or slicable range of characters into a range of lines
     using $(D '\r'), $(D '\n'), $(D '\v'), $(D '\f'), $(D "\r\n"),
-    $(XREF uni, lineSep), $(XREF uni, paraSep) and $(D '\u0085') (NEL)
+    $(REF lineSep, std,uni), $(REF paraSep, std,uni) and $(D '\u0085') (NEL)
     as delimiters. If $(D keepTerm) is set to $(D KeepTerminator.yes), then the
     delimiter is included in the slices returned.
 
@@ -2698,8 +2698,8 @@ public:
 
   See_Also:
     $(LREF splitLines)
-    $(XREF algorithm, splitter)
-    $(XREF regex, splitter)
+    $(REF splitter, std,algorithm)
+    $(REF splitter, std,regex)
  */
 auto lineSplitter(KeepTerminator keepTerm = KeepTerminator.no, Range)(Range r)
     if ((hasSlicing!Range && hasLength!Range && isSomeChar!(ElementType!Range) ||
@@ -2819,15 +2819,15 @@ unittest
 }
 
 /++
-    Strips leading whitespace (as defined by $(XREF uni, isWhite)).
+    Strips leading whitespace (as defined by $(REF isWhite, std,uni)).
 
     Params:
         input = string or ForwardRange of characters
 
     Returns: $(D input) stripped of leading whitespace.
 
     Postconditions: $(D input) and the returned value
-    will share the same tail (see $(XREF array, sameTail)).
+    will share the same tail (see $(REF sameTail, std,array)).
 
     See_Also:
         Generic stripping on ranges: $(REF _stripLeft, std, algorithm, mutation)
@@ -2893,7 +2893,7 @@ unittest
 }
 
 /++
-    Strips trailing whitespace (as defined by $(XREF uni, isWhite)).
+    Strips trailing whitespace (as defined by $(REF isWhite, std,uni)).
 
     Params:
         str = string or random access range of characters
@@ -3055,7 +3055,7 @@ unittest
 
 /++
     Strips both leading and trailing whitespace (as defined by
-    $(XREF uni, isWhite)).
+    $(REF isWhite, std,uni)).
 
     Params:
         str = string or random access range of characters
@@ -3158,7 +3158,7 @@ auto strip(Range)(auto ref Range str)
     $(D delimiter), then it is returned unchanged.
 
     If no $(D delimiter) is given, then one trailing  $(D '\r'), $(D '\n'),
-    $(D "\r\n"), $(D '\f'), $(D '\v'), $(XREF uni, lineSep), $(XREF uni, paraSep), or $(XREF uni, nelSep)
+    $(D "\r\n"), $(D '\f'), $(D '\v'), $(REF lineSep, std,uni), $(REF paraSep, std,uni), or $(REF nelSep, std,uni)
     is removed from the end of $(D str). If $(D str) does not end with any of those characters,
     then it is returned unchanged.
 
@@ -4744,7 +4744,7 @@ unittest
 
     See_Also:
         $(LREF tr)
-        $(XREF array, replace)
+        $(REF replace, std,array)
 
     Params:
         str        = The original string.
@@ -5012,7 +5012,7 @@ private void translateImpl(C1, T, C2, Buffer)(C1[] str,
 
     See_Also:
         $(LREF tr)
-        $(XREF array, replace)
+        $(REF replace, std,array)
 
     Params:
         str        = The original string.
@@ -5447,7 +5447,7 @@ S squeeze(S)(S s, in S pattern = null)
 /***************************************************************
  Finds the position $(D_PARAM pos) of the first character in $(D_PARAM
  s) that does not match $(D_PARAM pattern) (in the terminology used by
- $(XREF string,inPattern)). Updates $(D_PARAM s =
+ $(REF inPattern, std,string)). Updates $(D_PARAM s =
  s[pos..$]). Returns the slice from the beginning of the original
  (before update) string up to, and excluding, $(D_PARAM pos).
 

diff --git a/std/traits.d b/std/traits.d
@@ -3330,7 +3330,7 @@ Returns:
 Note:
  An enum can have multiple members which have the same value. If you want
  to use EnumMembers to e.g. generate switch cases at compile-time,
- you should use the $(XREF typetuple, NoDuplicates) template to avoid
+ you should use the $(REF NoDuplicates, std,typetuple) template to avoid
  generating duplicate switch cases.
 
 Note:

diff --git a/std/typecons.d b/std/typecons.d
@@ -310,7 +310,7 @@ for the second, and so on.
 
 The choice of zero-based indexing instead of one-base indexing was
 motivated by the ability to use value `Tuple`s with various compile-time
-loop constructs (e.g. $(XREF meta, AliasSeq) iteration), all of which use
+loop constructs (e.g. $(REF AliasSeq, std,meta) iteration), all of which use
 zero-based indexing.
 
 Params:
@@ -6888,7 +6888,7 @@ However, member types in `struct`s or `class`es are not replaced because there
 are no ways to express the types resulting after replacement.
 
 This is an advanced type manipulation necessary e.g. for replacing the
-placeholder type `This` in $(XREF variant, Algebraic).
+placeholder type `This` in $(REF Algebraic, std,variant).
 
 Returns: `ReplaceType` aliases itself to the type(s) that result after
 replacement.

diff --git a/std/typetuple.d b/std/typetuple.d
@@ -12,7 +12,7 @@ module std.typetuple;
 public import std.meta;
 
 /**
- * Alternate name for $(XREF meta,AliasSeq) for legacy compatibility.
+ * Alternate name for $(REF AliasSeq, std,meta) for legacy compatibility.
  */
 alias TypeTuple = AliasSeq;
 

diff --git a/std/uni.d b/std/uni.d
@@ -4,7 +4,7 @@
     $(P The $(D std.uni) module provides an implementation
     of fundamental Unicode algorithms and data structures.
     This doesn't include UTF encoding and decoding primitives,
-    see $(XREF _utf, decode) and $(XREF _utf, encode) in std.utf
+    see $(REF decode, std,_utf) and $(REF encode, std,_utf) in std.utf
     for this functionality. )
 
     $(P All primitives listed operate on Unicode characters and
@@ -1851,7 +1851,7 @@ public alias CodepointSet = InversionList!GcPolicy;
 // public alias CodepointInterval = Tuple!(uint, "a", uint, "b");
 
 /**
-    The recommended type of $(XREF _typecons, Tuple)
+    The recommended type of $(REF Tuple, std,_typecons)
     to represent [a, b$(RPAREN) intervals of $(CODEPOINTS). As used in $(LREF InversionList).
     Any interval type should pass $(LREF isIntegralPair) trait.
 */
@@ -2293,8 +2293,8 @@ public:
         open-right intervals and feed it to $(D sink).
         )
         $(P Used by various standard formatting facilities such as
-         $(XREF _format, formattedWrite), $(XREF _stdio, write),
-         $(XREF _stdio, writef), $(XREF _conv, to) and others.
+         $(REF formattedWrite, std,_format), $(REF write, std,_stdio),
+         $(REF writef, std,_stdio), $(REF to, std,_conv) and others.
         )
         Example:
         ---
@@ -4322,9 +4322,9 @@ private template buildTrie(Value, Key, Args...)
         In other words $(LREF mapTrieIndex) should be a
         monotonically increasing function that maps $(D Key) to an integer.
 
-        See_Also: $(XREF _algorithm, sort),
-        $(XREF _range, SortedRange),
-        $(XREF _algorithm, setUnion).
+        See_Also: $(REF sort, std,_algorithm),
+        $(REF SortedRange, std,_range),
+        $(REF setUnion, std,_algorithm).
     */
     auto buildTrie(Range)(Range range, Value filler=Value.init)
         if (isInputRange!Range && is(typeof(Range.init.front[0]) : Value)
@@ -7116,7 +7116,7 @@ unittest
 }
 
 /**
- * By using $(XREF utf, byUTF) and its aliases, GC allocations via auto-decoding
+ * By using $(REF byUTF, std,utf) and its aliases, GC allocations via auto-decoding
  * and thrown exceptions can be avoided, making `icmp` `@safe @nogc nothrow pure`.
  */
 @safe @nogc nothrow pure unittest
@@ -8203,7 +8203,7 @@ private auto toCaser(alias indexFn, uint maxIdx, alias tableFn, alias asciiConve
  *
  * Does not allocate memory.
  * Characters in UTF-8 or UTF-16 format that cannot be decoded
- * are treated as $(XREF utf, replacementDchar).
+ * are treated as $(REF replacementDchar, std,utf).
  *
  * Params:
  *      str = string or range of characters
@@ -8423,7 +8423,7 @@ private auto toCapitalizer(alias indexFnUpper, uint maxIdxUpper, alias tableFnUp
  *
  * Does not allocate memory.
  * Characters in UTF-8 or UTF-16 format that cannot be decoded
- * are treated as $(XREF utf, replacementDchar).
+ * are treated as $(REF replacementDchar, std,utf).
  *
  * Params:
  *      str = string or range of characters
@@ -8958,7 +8958,7 @@ unittest
     to produce an algorithm that can convert a range of characters to upper case
     without allocating memory.
     A string can then be produced by using $(XREF_PACK algorithm,mutation,copy)
-    to send it to an $(XREF array, appender).
+    to send it to an $(REF appender, std,array).
 +/
 @safe pure nothrow @nogc
 dchar toUpper(dchar c)

diff --git a/std/utf.d b/std/utf.d
@@ -3103,7 +3103,7 @@ enum dchar replacementDchar = '\uFFFD';
  * Iterate a range of char, wchar, or dchars by code unit.
  *
  * The purpose is to bypass the special case decoding that
- * $(XREF array,front) does to character arrays.
+ * $(REF front, std,array) does to character arrays.
  * Params:
  *      r = input range of characters, or array of characters
  * Returns:

diff --git a/std/uuid.d b/std/uuid.d
@@ -161,7 +161,7 @@ public struct UUID
          * possible to read, compare and use all these Variants, but
          * UUIDs generated by this module will always be in rfc4122 format.
          *
-         * Note: Do not confuse this with $(XREF _variant, _Variant).
+         * Note: Do not confuse this with $(REF _Variant, std,_variant).
          */
         enum Variant
         {
@@ -518,7 +518,7 @@ public struct UUID
          * RFC 4122 defines different internal data layouts for UUIDs.
          * Returns the format used by this UUID.
          *
-         * Note: Do not confuse this with $(XREF _variant, _Variant).
+         * Note: Do not confuse this with $(REF _Variant, std,_variant).
          * The type of this property is $(MYREF3 std.uuid.UUID.Variant, _Variant).
          *
          * See_Also:
@@ -1208,7 +1208,7 @@ unittest
 /**
  * Params:
  *      randomGen = uniform RNG
- * See_Also: $(XREF random, isUniformRNG)
+ * See_Also: $(REF isUniformRNG, std,random)
  */
 UUID randomUUID(RNG)(ref RNG randomGen)
 if (isInputRange!RNG && isIntegral!(ElementType!RNG))

diff --git a/std/zip.d b/std/zip.d
@@ -155,7 +155,7 @@ final class ArchiveMember
 
     /**
      * Set the OS specific file attributes, as obtained by
-     * $(XREF file,getAttributes) or $(XREF file,DirEntry.attributes), for this archive member.
+     * $(REF getAttributes, std,file) or $(REF DirEntry.attributes, std,file), for this archive member.
      */
     @property void fileAttributes(uint attr)
     {