[Question]
  [
Your task is pretty simple. Given two floats, bitwise xor the binary representation of them, and output that as a float.
For example,
```
Normal: 16.7472 ^ 123.61 = 7.13402e-37
Binary: 01000001100001011111101001000100 ^ 01000010111101110011100001010010 = 00000011011100101100001000010110
Normal: 2.2 ^ 4.4 = 1.17549e-38
Binary: 01000000000011001100110011001101 ^ 01000000100011001100110011001101 = 00000000100000000000000000000000
Normal: 7.898 ^ 3.4444 = 1.47705e-38
Binary: 01000000111111001011110001101010 ^ 01000000010111000110101001111111 = 00000000101000001101011000010101
```
Restrictions/clarifications:
* Input/output can be given by any [convenient method](https://codegolf.meta.stackexchange.com/questions/2447/default-for-code-golf-input-output-methods).
* The program can be a full program or just a function; either is fine.
* The float type can be any size, but the minimum size is 2 bytes.
* [Standard loopholes are forbidden.](https://codegolf.meta.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default)
* Shortest code wins.
  
[Answer]
# x86-64 machine code, 4 bytes
```
0f 57 c1 c3
```
In assembly:
```
xorps xmm0, xmm1
ret
```
This is a callable function that takes two floats or doubles as arguments (in `xmm0` and `xmm1`) and returns a float or double (in `xmm0`).
That matches the calling conventions of both Windows x64 *and* the x86-64 SysV ABI, and works for floats as well as doubles. (They're passed / returned in the low 4 or 8 bytes of XMM registers).
[Answer]
# [C++ (gcc)](https://gcc.gnu.org/), ~~74~~ 32 bytes
```
#define f(x,y)*(int*)x^=*(int*)y
```
[Try it online!](https://tio.run/##LcndCoMgGIDhc6/igyA0XGAbBaW7lIH4M4TSWAZKdO1uwY7eB161rre3UqVyXs27NsBd2OLHyOVZKm2s8wYsTjSTBjsfG5Je4q9cfoFFOo8JOhCAnYOMkATr2@ExdBSyYN297dl0TVwnWmdyeYt6HFXYI3AOaUJn@QI "C++ (gcc) – Try It Online")
I haven’t previously golfed in C++ so am grateful to all those who helped halve the size of the code! A macro which takes pointers to two floats as its arguments and modified the first to return the result. 
Thanks to @12Me1 for saving 2 bytes and @Arnauld for saving 4! Thanks to @Nishioka for saving another 14, @Neil a further 6 and @AZTECCO and @Nishioka another 11! Thanks to @PeterCordes for saving 5 bytes!
[Answer]
# ARM Thumb Machine Code, 6 4 Bytes
48 40 70 47
In assembly:
```
EORS R0, R1 ; Exclusive Or of the first two params, store result in the return register
BX LR       ; Branch to the value stored in the Link Register (Return address)
```
Under the standard Arm calling convention, the first two parameters are passed in the registers R0 and R1, results are returned in R0, and LR holds the return address. Assuming you're using the soft float ABI with 32 bit floats, this will perform the desired operation in 4 bytes.
-2 bytes thanks to Cody Gray
[Answer]
# [Python 3](https://docs.python.org/3/) + numpy, ~~75~~ 59 bytes
```
lambda x,y:(x.view("i")^y.view("i")).view("f")
import numpy
```
[Try it online!](https://tio.run/##K6gsycjPM/6fZhvzPycxNyklUaFCp9JKo0KvLDO1XEMpU0kzrhLB1oQy05Q0uTJzC/KLShTySnMLKv8XFGXmlWikaYB5emk5@YklxkYahmZ65ibmRpo6aMJGxnpmhpqamv8B "Python 3 – Try It Online")
Defines a lambda which takes two numpy float32 arrays as its arguments and returns a numpy float32 array. 
Thanks to @ShadowRanger for saving 14 bytes, and Joel a further 2!
If the import can be dropped (since my lambda itself calls methods on numpy objects rather than any base numpy functions), I could save a further 13 bytes. I’m uncertain on this from the code golf standard rules. 
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly) + numpy, ~~89~~ 77 bytes
```
“(F(“I^F(“IvF).item()”;"F“¢lẒṾ:/²)Ɓɱ¡vẠ⁷5Rʠ¡7ɼṆṪ{ė4¶Gẉn`¡Ð}ṫȥṄo{b»Ḳ¤¹ṣḢ}jʋƒŒV
```
[Try it online!](https://tio.run/##AZoAZf9qZWxsef//4oCcKEYo4oCcSV5GKOKAnEl2RikuaXRlbSgp4oCdOyJG4oCcwqJs4bqS4bm@Oi/CsinGgcmxwqF24bqg4oG3NVLKoMKhN8m84bmG4bmqe8SXNMK2R@G6iW5gwqHDkH3huavIpeG5hG97YsK74biywqTCueG5o@G4on1qyovGksWSVv///zE2Ljc0NzIsMTIzLjYx "Jelly – Try It Online")
Has the dubious honour of being longer than the Python 3 code it reproduces, largely because of the need to convert to/from numpy objecte and the fact that numpy isn’t loaded by Jelly so the `__import__()` built-in has to be used. 
A monadic link taking the two floats as a list as its argument and returning a float.
Evaluates the following Python 3 code:
```
(__import__('numpy').float32(x).view("i")^__import__('numpy').float32(y).view("i")).view(__import__('numpy').float32).item()
```
where `x` and `y` are substituted with the input. 
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 14 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Full program. Prompts for 1-column matrix of two IEEE 754 64-bit floating-point numbers (binary64) from stdin. Prints one such number to stdout.
```
645⎕DR≠⌿11⎕DR⎕
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///qKO94L@ZiemjvqkuQY86Fzzq2W9oCOH0TQXJ/lcAgwKuR72rDM30zE3MjRQMjYz1zAy5kGSM9IwUTPRMkIXM9SwsLRSM9UyAAAA "APL (Dyalog Unicode) – Try It Online")
`⎕` prompt (numbers that collapse to non-floats can be forced into floats with the function `⊃⊢⎕DR⍨645,⍨⎕DR`)
`11⎕DR` convert to 1-bit Binary (1) **D**ata **R**epresentation (2-row, 64-column matrix)
`≠⌿` vertical XOR reduction
`645⎕DR` convert to 64-bit float (5) **D**ata **R**epresentation (single number)
[Answer]
# [VAX BASIC (later VMS BASIC, then Compaq Basic)](https://www.vmssoftware.com/pdfs/HP_branded_docs_1st_batch/5424pro.pdf), 11 bytes
```
H = F XOR G
```
Seems a bit silly to me, obviously, older languages will do better because they didn't worry abut strong-typing issues as much.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), 59 bytes
```
@(a,b)(t=@typecast)(bitxor(t(a,u='int32'),t(b,u)),'single')
```
[Try it online!](https://tio.run/##LclBCoAgEAXQ4zgfhlmYW6GraGgIoVFT1OktqN2D1yYNZ@rZi0gfKXAEqR/1XtMUdgXFolfbSN86vClVB2vASpEPgM1e6rwkg57pI1mx4N9OHNAf "Octave – Try It Online")
Typecast is the MATLAB/Octave way of casting without changing the underlying bits. This is required because `bitxor` only works on integers. No idea why they never implemented floating point numbers, even though you can explicitly specify the `AssumedType` as a third argument to `bitxor`. I guess the only use is recreational programming.
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), 92 bytes
```
x=>BitConverter.Int32BitsToSingle(x.Aggregate(0,(a,b)=>a^BitConverter.SingleToInt32Bits(b)))
```
[Try it online!](https://tio.run/##VctBC8IgGMbxe59EwSRst02homDnBh2iQOVVBFNQV4Pos9tgEHR64M/z03mts6unMeiuP4bxAUkqD53xURZBljG8TlzsXTnE8IRUINE@lC2bSx7i2QXrAU10Z20CKwugDUGSKMyFvP@p5TrEn0YKY1zb1SW5mRkU4HW9vRllhjS0MR@M2/oF "C# (Visual C# Interactive Compiler) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, ~~31~~ 27 bytes
*-4 bytes thanks to Grimy*
```
$\=unpack f,$a^=pack f,$_}{
```
[Try it online!](https://tio.run/##K0gtyjH9/18lxrY0ryAxOVshTUclMc4Wxoyvrf7/39BMz9zE3IjL0MhYz8zwX35BSWZ@XvF/3QIA "Perl 5 – Try It Online")
[Answer]
# [MATL](https://github.com/lmendo/MATL), 10 bytes
```
4Z%Z}Z~9Z%
```
[Try it online!](https://tio.run/##y00syfn/3yRKNao2qs4ySvX//2gjPSMFEz2TWAA "MATL – Try It Online")
Splitting with `Z}` was shorter than taking two inputs `,4Z%]`
[Answer]
# C, 23 bytes
```
f(int*x,int*y){*x^=*y;}
```
[Try it online!](https://tio.run/##LYzRCoMgGIXvfYqfxkLDyayoi9aeZAxCkwmlo9lQomd3RTsXBz7OxxEXJ0SMCmvjMk/3DmTJ/LPNQrPGkzZimGUPt4@T2rLXHaHNgbHTBn@tlgQtCLaowXYOPLTAK1aXda4ohJ3yglVcNYeEU08hDeTA97RdKZycGS8L9TAJBf@fpt7Nk4Frg9b4Aw)
This might be a bit shifty; it takes the pointers to `float`s as pointers to `int`s.
However, it does work (this is C after all).
This takes advantage of acceptable input by taking a pointer to the variable and modifying it in-place. No (usable) value is returned.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), ~~105~~ 101 bytes
*Shorter Node version suggested by @Neil*  
*Saved 4 more bytes thanks to @ShieruAsakoto*
Takes input as `(x)(y)`.
```
x=>y=>(v=Buffer(4),v.writeInt32LE((g=n=>v.writeFloatLE(n)&&v.readInt32LE())(x)^g(y)),v.readFloatLE())
```
[Try it online!](https://tio.run/##ZYxRC4IwFEbf@yFyL9QF51B7mA9BQdBvCIZuYowt5lr6621CPkTf4zmH7yGjHFs/PMPBuk4tWiyTaGbRQBSnl9bKA8d9pLcfgrraULDbGaAXVjRfeDFOhgQtZlkkr2S3ZYgw4b2HGdeH1Wwt4tI6OzqjyLgeNOQlVbxiCDkrqMwRd7@eUXKc@J@oqD7WCAXxtHT7AQ "JavaScript (Node.js) – Try It Online")
---
# JavaScript (ES6), 115 bytes
Takes input as an array of 2 floats.
```
a=>(v=new DataView(new ArrayBuffer(4))).getFloat32(v.setUint32([x,y]=a.map(n=>v.getUint32(v.setFloat32(0,n))),x^y))
```
[Try it online!](https://tio.run/##bYxBDoIwEEX3noJlm9SJQAO6KInGeAPdEEwm2BIMtgRqgdNjMboxzur/vPfnjg77sqtbu9bmJmclZhQZcULLITiixUstB7KUfdfhdHgqJTvCKaVQSXtqDNo4Ig56ac@1XnI@sqkQCA9siRaZW7wPemvfzYZp/4WN14nSuTS6N42ExlREkTxMIOVpxIIwiiEJC0pXP0YEnnLgf1AK292WBTFwf57PLw "JavaScript (Node.js) – Try It Online")
[Answer]
# [Java (JDK)](http://jdk.java.net/), ~~109~~ ~~76~~ 63 bytes
```
a->b->a.intBitsToFloat(a.floatToIntBits(a)^a.floatToIntBits(b))
```
[Try it online!](https://tio.run/##dU@xbsIwEJ3tr7jRlhqrRWyUDB2QOnSCDVHpEiBy6thWfEFEFd/u2iFdqOrh/O7dvbt3LV6waI9fUXfe9QRtytVA2qjzYGvSzqrNDFac@6EyuobaYAjwgdrCN2czGQgpfRenj9ClkthSr22zPwD2TZC5k52NQ4IrrGGTkfLYh9MERW7aPx/kisPDu4vGf0UvWcTYr83XqfT0mOZYls06YlFWRYlKW3rTFHZuHqWmPTv3fucFys8/XCVlZCxv246BTp1yQ/KTziRjRaPQezOKq5zBKLOxG7/FuFCLuFTLHw)
Been a while since I golfed in Java and I'm not certain if I need the declaration on the LHS as part of the byte count? If it used DoubleBinaryOperator the LHS would be shorter, but the RHS would have to use Double.doubleToLongBits and Double.longBitsToDouble, so that's actually longer.
Thanks to Neil for a substantial savings on the byte count!
Thanks to Unmitigated for currying the way to another improvement!
[Answer]
## [Wolfram Mathematica](https://reference.wolfram.com), 50 bytes
```
BitXor@@(FromDigits[RealDigits[#,2,32,0][[1]],2]&)
```
Although I strongly suspect that this could be more golfed, the two extra arguments in `RealDigits` function seem to be necessary for getting a correct result.
[Try it online!](https://tio.run/##y00syUjNTSzJTE78H1CUmVcS/d8psyQiv8jBQcOtKD/XJTM9s6Q4Oig1MQfKVNYx0jE20jGIjY42jI3VMYpV0/yv71BtqAcU1jOtjf0PAA)
[Answer]
# [Lua](https://www.lua.org), 73 bytes
```
a,b=('II'):unpack(('ff'):pack(...))print((('f'):unpack(('I'):pack(a~b))))
```
[Try it online!](https://tio.run/##yylN/P8/USfJVkPd01Nd06o0ryAxOVtDQz0tDcgDs/X09DQ1C4oy80o0QOLIijxhahLrkjSB4P///4ZmeuYm5kb/DY2M9cwMAQ "Lua – Try It Online")
This code assumes 4-bytes unsigned integers and floats which is configuration on `tio.run`. Run as full program with input as arguments.
[Answer]
# [Ruby](https://www.ruby-lang.org/), ~~78~~ 67 bytes
-11 bytes thanks to @grawity.
```
->x{[x.pack("gg").unpack("NN").inject(&:^)].pack(?N).unpack(?g)[0]}
```
[Try it online!](https://tio.run/##KypNqvyfZhvzX9euojq6Qq8gMTlbQyk9XUlTrzQPwvHzA3Iy87JSk0s01KziNGMhiuz94Ers0zWjDWJr/xeUlhQrpOklJ@bkaEQbmumZm5gb6SgYGhnrmRnGanKhSBvpAaVM9EzQxc31LCwtdBSM9UyAIFbzPwA "Ruby – Try It Online")
Input is an array of two floats.
[Answer]
# MMIX, 8 bytes (2 instrs)
Really, just put in an xor command.
```
00000000: c600 0001 f801 0000                      İ¡¡¢ẏ¢¡¡
```
```
xorflt  XOR $0,$0,$1
        POP 1,0
```
Simples.
[Answer]
# [Julia 1.0](http://julialang.org/), 40 bytes
```
~=reinterpret
!x=Float64~⊻((Int~x)...)
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/v862KDUzryS1qKAotYRLscLWLSc/scTMpO5R124NDc@8kroKTT09Pc3/DsUZ@eUKitFGekY6JnomsVxcacZGGhWaEA3GRnANQCZECxcXRA9IHVQRXLfmfwA "Julia 1.0 – Try It Online")
expects `Float64`s on a 64 bit platform. On a 32 bit platform, use `Float32`
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 36 bytes
```
f::!Real!Real->Real
f _ _=code{xor%}
```
[Try it online!](https://tio.run/##NZBNb4JAEIbv/IopTSOkgAUJWqOe6sGkh6b2BmgWWHCbZZfCakuMf710kLrJzrzPfsy8mZRTIrpSZkdOoSRMdPl8fvdOCb8Ge9VHLYc97JepzOj5R9YPl46VlawVbFW2Fifrg/4oGI9BCt5CTb@OrKYZ5LKGqqZKtZiYUEwUoA4UFG1Uo20VwQJL@JRMgB6JSOgQ3kAHThWkeJ0DgQTwNCSweAQddrhRJAMtB0phjuYryFhTcdLiYwsSC9I4higCoycTFvbQOta@mToMGguEhhs4U3/qWeB6EydwTQsMz0H0Hb/XU2f2PLNg4vi4zFi7Nanxc29TYC6Q0OT5nuUGa9YnKgwx9nZG4NuVaZqjp9HIHUVRtbBD13ECP75oxf@c7dVGKK24zVfIvawu3W@ac1I0nb157V5aQUqWIiRXfuNE4XDLPw "Clean – Try It Online")
Thankfully the `Real` and `Int` types are the same sizes on 64-bit platforms...  
Unfortunately requires a complete signature otherwise the graph turns into a pretzel and everything segfaults.
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 87 bytes
```
x=>(v=Buffer(8),x.map((c,i)=>v.writeFloatLE(c,h=4*i)),v.map(e=>e^v[h++]).readFloatLE())
```
[Try it online!](https://tio.run/##bcpBDoIwEIXhvSfpSJ2E0gAuysJEV96AYNLgVGqQkoKV21di4sb4lu//7jroqfV2nHeDu1I0Ki6qYkEdnsaQZyXwBR96ZKzlFlQV8OXtTKfe6fl8XM9Oya0F4OGjSFV0CXWXJA2gJ339QoDYumFyPWHvbsywOs2xkIXgqcgwTxuAzQ8QKLhE@acUWO5LnqFct@b4Bg "JavaScript (Node.js) – Try It Online")
silly
[Answer]
# [Factor](https://factorcode.org/), 40 bytes
```
[ [ float>bits ] bi@ bitxor bits>float ]
```
[Try it online!](https://tio.run/##S0tMLskv@h8a7OnnbqWQm1iSoZCdWpSXmqNQUJRaUlJZUJSZV6JgzcVlpGekYKJn8j9aIVohLSc/scQuKbOkWCFWISnTAYhLKvKLQFSxHVhSIfZ/cmJOjoLefwA "Factor – Try It Online")
```
                     ! 2.2 4.4
[ float>bits ] bi@   ! 1074580685 1082969293
bitxor               ! 8388608
bits>float           ! 1.175494350822288e-38
```
]