Python 2, 50

• 3 bytes saved thanks to @Dennis.

lambda s:UUID(int=UUID(s).int+1)

from uuid import*

Try it online!

JavaScript (ES6), 85 bytes

The output string is in lowercase.

s=>(g=(c,x=+('0x'+s[--n])+!!c)=>1/x?g(x>>4)+(x&15).toString(16):~n?g(c)+'-':'')(n=36)

Try it online!

Commented

s => (                   // s = GUID

  g = (                  // g = recursive function taking:

    c,                   //   c = carry from the previous iteration

    x = +('0x' + s[--n]) //   x = decimal conversion of the current digit

        + !!c            //       add the carry

  ) =>                   //

    1 / x ?              // if x is numeric:

      g(x >> 4) +        //   do a recursive call, using the new carry

      (x & 15)           //   and append the next digit

      .toString(16)      //   converted back to hexadecimal 

    :                    // else:

      ~n ?               //   if n is not equal to -1:

        g(c)             //     do a recursive call, leaving the current carry unchanged

        + '-'            //     and append a hyphen

      :                  //   else:

        ''               //     stop recursion

)(n = 36)                // initial call to g with n = 36 and a truthy carry

05AB1E, 17 15 18 bytes

Saved 2 bytes thanks to Kevin Cruijssen

'-K1ìH>h¦Ž¦˜S·£'-ý

Try it online!
or as a Test Suite

Explanation

'-K                  # remove "-" from input

   1ì                # prepend a 1 (to preserve leading 0s)

     H               # convert from hex to base 10

      >              # increment

       h             # convert to hex from base 10

        ¦            # remove the extra 1

         Ž¦˜S·       # push [8, 4, 4, 4, 12]

              £      # split into parts of these sizes

               '-ý   # join on "-"

APL (Dyalog Unicode), 46 bytes^SBCS

Anonymous tacit prefix function.

⎕CY'dfns'

(∊1hex 16(|+1⌽=)⍣≡1+@32dec¨)@('-'≠⊢)

Try it online!

⎕CY'dfns' copy the "dfns" library (to get hex and dec)

(…)

 ⊢ the argument

 ≠ differs from

 '-' a dash
(…)@ on the subset consisting of the locations at which the above criterion is true, apply:

 dec¨ convert each hexadecimal character to a decimal number

 …@32 at position 32 (the last digit), apply:

  1+ increment

 16(…)⍣≡ repeatedly apply with left argument 16 until stable:

  = compare (gives mask where the hexadecimal digits are 16)

  1⌽ cyclically rotate one step left (this is the carry bit)

  |+ to that, add the division remainder when divided (by sixteen, thus making all 16 into 0)

 1hex  turn digits into length-one hexadecimal character representations

 ∊ ϵnlist (flatten)

Java 11, 152 149 111 108 bytes

s->{var b=s.getLeastSignificantBits()+1;return new java.util.UUID(s.getMostSignificantBits()+(b==0?1:0),b);}

-38 bytes thank to @OlivierGrégoire.

-3 bytes thanks to @ASCII-only.

Try it online.

Explanation:

s->{         // Method with UUID as both parameter and return-type

  var b=s.getLeastSignificantBits()

             //  Get the 64 least significant bits of the input-UUID's 128 bits as long

        +1;  //  And increase it by 1

  return new java.util.UUID(

             //  Return a new UUID with:

    s.getMostSignificantBits()

             //   The 64 most significant bits of the input-UUID's 128 bits as long

    +(b==0?  //    And if the 64 least significant bits + 1 are exactly 0:

       1     //     Increase the 64 most significant bits by 1 as well

      :      //    Else:

       0,    //     Don't change the 64 most significant bits by adding 0

     b);}    //   And the 64 least significant bits + 1

Old 149 bytes answer:

s->{var t=new java.math.BigInteger(s.replace("-",""),16);return(t.add(t.ONE).toString(16)).replaceAll("(.{4})".repeat(5)+"(.*)","$1$2-$3-$4-$5-$6");}

Try it online.

Explanation:

s->{                              // Method with String as both parameter and return-type

  var t=new java.math.BigInteger( //  Create a BigInteger

         s.replace("-",""),       //  Of the input-string with all "-" removed

         16);                     //  Converted from Hexadecimal

  return(t.add(t.ONE)             //  Add 1

         .toString(16))           //  And convert it back to a Hexadecimal String

         .replaceAll("(.{4})".repeat(5)+"(.*)",

                                  //  And split the string into parts of sizes 4,4,4,4,4,rest

           "$1$2-$3-$4-$5-$6");}  //  And insert "-" after parts of size 8,4,4,4,

                                  //  and return it as result

Ruby -pl, 62 57 55 bytes

$_="%032x"%-~gsub(?-,"").hex

7.step(22,5){|i|$_[i]+=?-}

Try it online!

Python 2, 113 112 bytes

def f(s):a=hex(int(s.replace('-',''),16)+1+2**128);return'-'.join((a[3:11],a[11:15],a[15:19],a[19:23],a[23:-1]))

Try it online!

Without imports

Retina 0.8.2, 21 bytes

T`FfdlL`0dlL`.[-Ff]*$

Try it online! Link includes test cases. 9 becomes a. Explanation: The regex matches all trailing fs and -s plus one preceding character. The transliteration then cyclically increments those characters as if they were hex digits. Alternate approach, also 21 bytes:

T`L`l

T`fo`dl`.[-f]*$

Try it online! Link includes test cases. Works by lowercasing the input to simplify the transliteration. Would therefore be 15 bytes if it only had to support lowercase. Try it online! Link includes test cases.

MATLAB, 138 bytes

a=1;Z=a;for r=flip(split(input(''),'-'))'

q=r{:};z=dec2hex(hex2dec(q)+a,nnz(q));try

z+q;a=0;catch

z=~q+48;end

Z=[z 45 Z];end;disp(Z(1:36))

Fixed a bug in case a chunk is all zeros. Also golfed off a lot by abusing try/catch. Net result: 0 bytes saved.

An attempt to 'cheat' by using java.util.UUID failed because the long value returned from java.util.UUID.get[Most/Least]SignificantBits gets converted to a double which incurs a loss of precision. I invite you to take a look at this table and silently utter "...but why?"

Explanation

The hex2dec function spits out a double, so it cannot process the entire GUID at once to avoid exceeding flintmax. Instead, we have to process the GUID chunk by chunck, using split. The variable a checks if we need to carry a one, and cheatingly also is the initial increment we add. The condition for carrying over is whether the lengths of the original and incremented strings are no longer equal.

Original version was just under 160 bytes so I'd like to think this should not be easy to outgolf.

Python 2, 99 bytes

s='%032x'%-~int(input().replace('-',''),16)

print'-'.join((s[:8],s[8:12],s[12:16],s[16:20],s[20:]))

Try it online!

No uuid.UUID usage.

Python 2, 82 bytes

q='f0123456789abcdef--'

f=lambda s:[str,f][s[-1]in'f-'](s[:-1])+q[q.find(s[-1])+1]

Try it online!

No imports or hex conversion.

This scans from the back of the string, moving each character along the cycle 0123456789abcdef, with - going to itself. After it hits a symbol other than f or -, it stops scanning leftwards, and just returns the remainder unchanged. This solution isn't specific to the UUID format -- any number of blocks of any number of hex letters would work.

The base case of [str,f][s[-1]in'f-'](s[:-1]) is a trick I haven't seen used in a golf before. It terminates the recursion without any if, and, or, or other explicit control flow.

Based on the condition [s[-1]in'f-'] of the last character, the code either returns f(s[:-1]) or just s[:-1] unchanged. Since str is the identity on strings, we can select one of the functions [str,f] and apply it to s[:-1]. Note that the recursive call with f is not made if it is not chosen, getting around the common issue problem that Python eagerly evaluates unused options, leading to infinite regress in recursions.

C# (Visual C# Interactive Compiler), 77 bytes

x=>{for(int i=35,c;(x[i]=(char)((c=x[i--])<48?c:c==57?65:c>69?48:c+1))<49;);}

Try it online!

-1 byte thanks to @ASCIIOnly!

Anonymous function that takes a char as input and outputs by modifying an argument.

Input is scanned from right to left and replaced using the following rules.

• The - character is ignored and processing continues


• The F character is converted to 0 and processing continues


• The 9 character is converted to A and processing stops


• The characters A-E and 0-8 are incremented by 1 and processing stops

Perl 6, 65 bytes

{(:16(TR/-//)+1).base(16).comb.rotor(8,4,4,4,*)».join.join('-')}

Test it

Jelly, 20 bytes

-2 (and a bug fix) thanks to Dennis!

ØhiⱮṣ0µẎḅ⁴‘ḃ⁴ịØhṁj”-

Try it online!

Python 3, 50 bytes

from uuid import*

lambda u:UUID(int=UUID(u).int+1)

Try it online!

JavaScript (Node.js), 81 bytes

s=>s.replace(/.([f-]*)$/,(s,y)=>(('0x'+s[0]|0)+1).toString(16)+y.replace(/f/g,0))

Try it online!

PowerShell, 126 bytes

$a=("{0:X32}" -f (1+[Numerics.BigInteger]::Parse($args[0]-replace"-", 'AllowHexSpecifier')));5..2|%{$a=$a.Insert(4*$_,"-")};$a

Try it online!

Pretty trivial answer. Just thought I'd get the beloved PowerShell added to the list :)

Perl 5, 64 bytes

$c=reverse((1+hex s/-//gr)->as_hex);$c=~s/..$//;s/[^-]/chop$c/ge

The number of parentheses necessary here makes me sad, but -> binds very tightly, as ->as_hex is the quickest way I can find to get hexadecimal-formatted output.

Run with perl -Mbigint -p. Basically, it just converts the number to a bigint hexadecimal, adds one, and then subtitutes the digits of the result back into the original value, leaving dashes untouched.