text:
Space Cleaners!
A space cleaner is a special character which removes all spaces between it and the first non space character to its left and it is represented by a '!' character.
If it reaches the beginning of the string it stops.
Given a string output the string in any reasonable format after the cleaning process.
Trailing spaces at the end of the string must be still be in the output.
Remember that space cleaners remain after their job.
Input will only consist of printable ASCII characters.
This is code-golf, so least number of bytes win.
Test Cases
" ! a! !b c!d !" => "! a!!b c!d!"
"a    !" => "a!"
"!    a" => "!    a"
"!    !    !" => "!!!"
"! " => "! "

Some test cases would be good. I assume that the cleaners are represented by !s, since it isn't quite clear. So basically, this boils down to "remove any spaces before a space cleaner", correct?

Can we get some examples? What is the minimum string length? What do we do with the input string !? This looks like it would be trivially solved by a regex looking for any number of spaces followed by a bang?

Need some test cases,  " ! a!  !b c!d   !"=>"! a!!b c!d!"

May we choose which character to use as the "pipe cleaner"?

If the input ends with spaces can we omit them in the output?

Suggested test case "!      " => "!      "

@JoKing Yes, you are right.

@streetster Minimum string length is 0. For !, because the cleaner reaches the beginning of the string, it stops, and the process terminates, and ! was outputted.

@Shaggy Space-cleaner must be !, as stated in the question.

@AZTECCO Test case added. For the question, nope.

@TwilightSparkle I think you've made a copy-paste error here: "a    !" => "!    a". ;) Also, you might want to add a test case containing tabs instead of spaces (or a mixture of both).

@KevinCruijssen Mmmm, yep. EDIT: Fixed.

You should probably describe what "eats a space" means in the context of this puzzle.

@SriotchilismO'Zaic Edited.

@JoKing Tabs can appear, according to Kevin Cruijssen's test case.

@JoKing Since I'm pretty much new to Code Golf Stack Exchange, I really don't know what to do - e. g. shall the input restriction be language dependent.

@JoKing Thanks, will do.

05AB1E, 5 bytes
„ !¤:

Try it online!

Explanation
„ !                  # 2 char string " !"
   ¤                 # Push the tail of that (so "!")
    :                # Infinite replacement

JavaScript (ES6), 24 bytes
Thanks to @Nick Kennedy for the TIO link and -2 bytes, since I could omit the function name f=
_=>_.replace(/ +!/g,'!')

Try It Online
Nothing special, same regex as other answers. New to codegolf, was a simple one to translate to js. If anyone can think of improvements I'd love to see them.

Welcome to the site!

Welcome to the site! I like the underline obfuscation LOL.

Welcome! Would suggest having a Try it online link with a working example. Also you can move the naming of the lambda to a header and remove it from the byte count. e.g. https://tio.run/##BcExDoAgDADAr7QsQFRYXfArBCsQDREChu/XuyfMMKjf7dvmzsmxd4c3PbYSKCoLC9q8SpSaqb6jlmhKzSopAQgBAU8gvACF1vwD

@NickKennedy Thanks! I wasn't sure about the function naming, good to know. I considered the TIO link but figured it's easy enough to test JS with browser console. Although, I will edit it into my post.

Retina, 5 bytes
 +!
!

Try it online.
Not much to say. Simply removes all spaces in front of every ! with a simple replace.

4th test case !    !    ! -> !!! why not !    !! ?

@NahuelFouilleul Why not? I assume all space cleaners 'walk' simultaneously, so eventually they'll reach the start of the string for that test case. OP never stated the left one walks first, only that all space cleaners travel left.

maybe the OP should clarify

The assumption is correct. (Which, if I'm not mistaken, is equivalent to "the left ones first".)

PHP, 35 bytes
<?=preg_replace('/ +!/','!',$argn);

Try it online!
Just a simple RegEx replace.

Haskell, 48 42 bytes
-6 bytes thanks to H.PWiz!
g(' ':b)|'!':_<-g b=g b
g(a:b)=a:g b
g a=a

Try it online!
Explanation:
g(' ':b)                 -- Given a string starting with space
        |'!':_           -- Check if '!' is the first element of
              <-g b      -- The function applied to the rest of it
                   =g b  -- Return the function applied to the rest of it
g(a:b)=a:g b             -- Otherwise just apply the function recursively
g a=a                    -- Until the string is empty

You don't need parens around g b. Also, you can replace g b!!0=='!' with '!':_<-g b

R, 25 bytes
gsub(" +!","!",scan(,''))

Straightforward enough with a simple regex substitution!
Try it online!

brainfuck, 66 bytes
,[<<++++[->++++++++<]>>[-<-<+>>]<[+[[+]<<[.<]>[>]]<.>>]>>,]<<<[.<]

Try it online!
It's funny how much space is just taken up by constants, in this case making a space takes up more than a quarter of the code.

Haskell, 34 bytes
foldr(%)""
' '%r@('!':_)=r
c%s=c:s

Try it online!

Python 3, 50 bytes
f=lambda s:' !'in s and f(s.replace(' !','!'))or s

Try it online!
Port of Expired Data's 05AB1E answer, so make sure to upvote him!

Original answer:
Python 3, 63 bytes
lambda s:'!'.join(i.rstrip(' ')for i in(s+'_').split('!'))[:-1]

Try it online!

Isn't just using regex easier and shorter?

@KevinCruijssen Yes, for sure! I just like to try without.

ksh, 18 bytes
try it online!
echo ${1//+( )!/!}

zsh, 32 bytes
Since there's another zsh answer I changed to ksh. Thanks to @Gilles at unix.se for zsh help. try it online!
setopt ksh_glob;<<<${1//+( )!/!}

///, 6 bytes
/ !/!/

Try it online!
Replaces every occurrence of  ! with ! until it eats up all the spaces in front of the exclamation marks.
The language is a perfect match because it's built on find/replace. That's the only command you're given, and not a single special character or wild card to use in your patterns, except the \ which only serves to escape the /. Yet, it's Turing complete. It's really elegant!
The language is read by slash triplets, hence the name. Each one couches a find pattern and replace pattern. We have one such pattern here doing precisely what it says at the top. The first pair of slashes says to find all  ! and the second pair says to replace them with !.

What I intended. But input: / :(

Python 3, 38 bytes
lambda s:re.sub(' +!','!',s)
import re

A simple regex substitution. Replaces any amount of space plus an exclamation mark with just an exclamation mark.

Why using a raw string? lambda s:re.sub(' *!','!',s) is a byte shorter.

@Skillmon Man, that habit is hard to break for code golf. Thanks for pointing it out!

Perl 5 (-p), 9 bytes
s/ *!/!/g

TIO

Zsh with extended_glob, 14 bytes
<<<${1// #!/!}

Zsh with extended_glob is not an arbitrary whim: it's the language in which zsh completion functions are written. Inspired by roblogic's initial attempt. Try it online.

Charcoal, 22 bytes
≔ ηＦ⮌Ｓ«≡ι!≔ωη ≔ηι≔ η←ι

Try it online! Link is to verbose version of code. Explanation:
≔ η

h is a variable that specifies whether a space is being cleaned or not.
Ｆ⮌Ｓ«

Loop over the string in reverse as the spaces are cleaned to the left.
≡ι

Switch over the current character.
!≔ωη

If it's a ! then start cleaning spaces.
 ≔ηι

If it's a space then replace it with the space cleaning flag.
≔ η

Otherwise turn off space cleaning.
←ι

Print the current character leftwards.
Boring 15-byte version:
Ｗ№θ !≔⪫⪪θ !¦!θθ

Try it online! Link is to verbose version of code. Explanation:
Ｗ№θ !

Repeat while there are spaces to be cleaned.
≔⪫⪪θ !¦!θ

Clean up to one space per space cleaner.
θ

Output the result.

PowerShell, 22 bytes
$args-replace' +!','!'

Try it online!

Jelly, 11 bytes
œṣ⁾ !j”!µÐL

Try it online!

C (clang), 79 bytes
j,e;f(char*s){for(j=e=0;!e;e=!*s++)*s-32?s-=*s-33?j:0,j=0,*s&&putchar(*s):j++;}

Try it online!
Saved 1 thanks to @ceilingcat
*s && instead of !*s ||
j is used to jump back if there is no "!" after spaces.

Perl 6, 14 bytes
{S:g/\s+\!/!/}

Try it online!
Loses bytes over other regex solutions since I can't use a literal space and I have to escape the metaoperator !

J, 16 bytes
(#~1-' !'E.])^:_

Try it online!

Japt, 7 bytes
Recursive replacement. Could save 2 bytes if we could choose the "cleaner" character.
e" !"'!

Try it

I didn't get how did you save bytes by changing the cleaner character.

@TwilightSparkle, Japt has constants for a few characters & digits (e.g., T===0), which would allow me to do something like eS+TT (where S is Japt's constant for a single space).

Thanks for the explanation. I choose ! just because it's next to the space in the ASCII table.

Ruby -p, 14 bytes
gsub(/ +!/,?!)

Unfortunately the 13-byte gsub / +!/,?! doesn't work because Ruby interprets the first / as division instead of the start of a regex statement.
Try it online!

Java 8+, 26 bytes
Yet another regex port
s->s.replaceAll(" +!","!")

TIO

I think lambdas where first introduced in Java 8.

@JonathanFrech I had a brain short-circuit there

Pip, 8 bytes
aRw.'!'!

Try it online!
concatenates the whitespace regex variable w with an ! character. then replaces it with a single ! in the string.

Husk, 8 bytes
ωσ" !""!

Try it online!

AWK, 16 bytes
gsub(" *!","!")1

Try it online!
Similar regex to some others that were posted, just AWK-styled.  Adding a random number on the end makes sure it prints even if the input has no cleaner character.

Vyxal, 9 bytes
` *!`\!øṙ

Try it Online!
Another one ports the regex

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Write an interpreter for simplified 33
33 is a simple esolang I created. You may have seen me use it in a few questions. You're not going to be writing a full interpreter. The interpreter you will be writing is for a simplified version of 33.
This simplified 33 has two numeric registers: the accumulator and the counter. The accumulator holds all the post-arithmetic values, the counter is where numbers in the program come from. Both registers are initialized to 0.
0-9 | Appends the digit to the counter
a   | Adds the counter to the accumulator
m   | Subtracts the counter from the accumulator
x   | Multiplies the accumulator by the counter
d   | Divides the accumulator by the counter
r   | Divides the accumulator by the counter, but stores the remainder in the accumulator
z   | Sets the counter to 0
c   | Swaps the accumulator and counter
-----
p   | Outputs the current value of the accumulator as an ASCII character
o   | Outputs the current value of the accumulator as a formatted decimal number
i   | Outputs a newline character (0x0a)
-----
P   | Stores the ASCII value of the next character read in the accumulator
O   | Stores the next integer read into the accumulator
-----
n   | Skips the next instruction if the accumulator is not 0
N   | Skips the next instruction if the accumulator is 0
g   | Skips the next instruction if the accumulator is less than or equal to 0
G   | Skips the next instruction if the accumulator is greater than 0
h   | Skips the next instruction if the accumulator is greater than or equal to 0
H   | Skips the next instruction if the accumulator is less than 0

Test cases
Program / Input -> Output
2o          -> 0
25co        -> 25
1a0aoi      -> 11 (trailing newline)
Oo / 42     -> 42
Op / 42     -> *
1cNoo       -> 11
no          -> 0
Ogo / 2     -> 2
Ogoi / -4   -> (newline)
50a         -> (no output)
On12co / 12 -> 2

Clarifications

The input to your interpreter will be a valid simplified 33 program.
The input may be given in any acceptable format.
The output may be given in any acceptable format.
When dividing, truncate any decimal places.
A trailing newline is acceptable, but it must be consistent; as in, if there's an i at the end of the program, it should have two trailing newlines.
The accumulator and counter must be able to hold at least a signed byte (-128 to 127)
You may assume that the p instruction will never be given when the accumulator has an invalid ASCII character in it.
You may assume the O instruction will never be given unless there is a valid integer string (such as 3, -54, +23) left in the input.

How does O work?

@tsh Yes. I'll update that.

@EriktheOutgolfer It reads the integer in the same format that o outputs it

@TheOnlyMrCat If the remaining input is x-13, will O skip the x and read the -13? Or can we assume that there will always be an integer right where the O reads the input?

What is acceptable format for an integer input the interpreter must handle? Will +03 be valid input for integer?

+ and - are not valid commands in 33, and 33 only handles positive integers.

@A_ The accumulator and counter must be able to hold at least a signed byte (-128 to 127)

I believe that is internally, not externally.

N12 should skip the 1 command, since 1 and 2 are separate commands.

Let us continue this discussion in chat.

@TheOnlyMrCat In the official 33 interpreter, trying to read an integer containing letters is invalid. You need to make the challenge self-contained and explain what an interpreter should do with this input.

How does p behave if the accumulator is negative?

the example 1Noo should output 0 not 11.

JavaScript (Node.js), 264 bytes
S=>I=>[...S].map(s=>K?K=0:1/s?C=+(C+s):eval("A*=C;[A,C]=[C,A];K=!A;;K=A;K=A>0;A%=C;K=A<=0;A=A/C|0;I=I.replace(/-?\\d+/,n=>(A=+n,''));K=A>=0;O+=A;K=A<0;A+=C;C=0;;[A]=B(I[0]),I=I.slice(1);O+=`\n`;O+=B([A]);A-=C".split`;`[B(s)[0]*73%378%22]),A=C=K=0,O='',B=Buffer)&&O

Try it online!
Saved ~20 bytes, thanks to Arnauld's magic integer modulus.

253 bytes by converting the input to a buffer right away, re-using S as the result of the previous instruction and using a strict comparison with true.

Lua 5.3, 342 bytes
Code is provided as a cmdline argument, input is provided via stdin.
H=string.char R=io.read A=0 C=0 i=1 s=...while i<=#s do
b=s:byte(i)d=H(b)i=i+(({H=A<0,G=A>0,N=A==0,g=A<=0,h=A>=0,n=A~=0})[d]and 2or
1)io.write(({i='\n',o=A|0,p=H(A%255)})[d]or'')A,C=d=='O'and R'n'or d=='P'and
R(1):byte()or d=='d'and A//C or d=='r'and A%C or({a=A+C,c=C,m=A-C,x=A*C})[d]or
A,b>=48 and b<58 and b-48+C*10or({c=A,z=0})[d]or C end

Julia 1.0, 355 bytes
p=print
function f(s,a=0,c=0,i=1)
for x=s
z=findfirst(==(x),"amxdrzcpoiPOnNgGhH0123456789")
y=z-9
i<1&&(i=1;continue)
z<6 ? a=(+,-,*,÷,%)[z](a,c) :
z<7 ? c=0 :
z<8 ? ((a,c)=(c,a)) :
z<9 ? p(Char(a)) :
y<1 ? p(a) :
y<2 ? p("\n") :
y<3 ? a=0+read(stdin,UInt8) :
y<4 ? a=parse(Int,readline()) :
y<10 ? (!=,==,<=,>,>=,<)[y-3](a,0)&&(i=0) :
c=10c+y-10
end
end

Program provided as an argument, eg f("2o"), input taken from stdin.
Try it online!

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/


text:
Interpret Volatile
Interpret Volatile
Volatile is a stack-based esolang made by A_/a'_'/A that only has 8 instructions and is turing complete. However, it is also non-deterministic... meaning that programs don't always give the same output. Your task is to interpret this language.
Language specs
Taken from the esolangs page:
~: Push a random integer in any range of integers. Minimum range of 0 through 32768

+: Pop 2 values and push the sum of the 2 values

-: Like +, but subtracts

*: Multiply

/: Divide. 0-division will result in an error.

:: Duplicate the top of the stack

.: Output the top of the stack without popping it

(...): Execute ... inside a while loop when the top of the stack is not 0

Everything else is disregarded
Input
Note that these programs may randomly fail
~:/::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++.~:/:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.~:/:::::::::::::::::::::::::::::::::+++++++++++++++++++++++++++++++++.~:/::::::::::++++++++++.

~:-.~:/+.(~:/+.)

~:-:/

Output
73 102 109 109 112 45 33 120 112 115 109 101 34 11

0 1 2 3 4 5 6 7 8 9 ...

<Any Error Message>

More examples, as well as a reference implementation (use the second one, found under (Another) python 3 interpreter) can be found at https://esolangs.org/wiki/Volatile
Scoring
This is code-golf, so shortest answer in bytes wins
Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=191573;
var OVERRIDE_USER=78850;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="
"+q.body.replace(OVERRIDE_REG,"")+"
")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery(""+n.language+"").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
  <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654">

Winners by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}

{{LANGUAGE}}	{{NAME}}	{{SIZE}}

Is division supposed to round toward 0?

Does ~ push an integer, or any number?

Also, depending on the implementation, this might not really be non-deterministic. Sure, the esolang page claims it is, but that's only because of the way listed to push 1, which might divide by zero. ~ must be able to push zero, otherwise it's deterministic. Also, the RNG must always be able to return zero after any number of zeroes in a row.

Shouldn't that second input ~:-.~:/+.(~:/+.) start from 0 1 2 ... instead of 1 2 3 ...? The ~:-. would result in 0 which it outputs. Those interpreters on the Esolang page seem to confirm this (here the second).

Is the stack pre filled by infinity 0s? Or what will happen if try to + when there are only one values on the stack, or try to . when there are nothing on the stack? for example, rograms like ., ~+, :

@tsh, no, the stack is not prefilled. When there is nothing, halt with an error.

Suggestion to add test case: ~:-.(~:/+.)

Got a nested loop test case?

pops two values and subtracts them? subtraction isnt commutative

If this is turing complete, then there should be a solution in this esoslang…

05AB1E, 35 bytes
"~:/.()"”žGÝΩ DŠéõq}÷ = [D_# }”#‡.V

Try it online!
Transpiles Volatile code to 05AB1E, then evals it. *, + and - can be left as-is. :, ., and ) have direct one-byte equivalent. The other commands take a few bytes each. Unfortunately, 05AB1E does not crash on division by 0, so this is instead implemented by a conditional "quit if top of stack == 0".

Does this work correctly for the loop. If I input the second test case it seems to ouput 0 and 1 correctly before the loop, but then it starts outputting the Volatile program (the implicit input) itself. I like that D Doingõq dictionary string for the if-statement, btw! :)

@KevinCruijssen the example seems to assume the loop is a while peek, but in the reference interpreter it's a while pop. The example can be fixed by adding some : (TIO). Alternatively, my code can be changed to a while peek by adding a D.

Both reference interpreters from the Esolang still output 0 1 2 3 ..., though. I haven't looked at their source code, but just tried both of them.

@KevinCruijssen Oh, the function is named pop but is actually a peek. Maximally confusing. I added the D in my code.

Lol.. Confusing builtin names reminds me of Java's replace vs replaceAll (which both replace all occurrences, but the replaceAll uses regexes and the other one not). xD

Julia 1.0, 334 bytes
a\b=push!(a,b)
√a=pop!(a)
v(q,s=[],l=0)=(i=1;
for c in q
!r=c==r
i+=1
!')' ? (l<1 && break;l-=1) :
!'(' ? (while s[end]!=0 v(q[i:end],s) end;l+=1) :
l>0 ? continue :
!'~' ? s\rand(Int) :
!'+' ? s\(√s+√s) :
!'-' ? s\(√s-√s) :
!'*' ? s\(√s*√s) :
!'/' ? s\(√s÷√s) :
!':' ? s\s[end] :
!'.' ? print(s[end]," ") : 0
end)

My first "interpreter" of any type, it was easier than I expected. I did some basic golfing, but there is probably room for more. I made it print a space after the output for . to mach to example output. The ungolfed version is in the header at the TIO link. Example usage v("~:-:/").
+41 bytes to fix the bug Night2 pointed out by adding a loop counter. Now I see why transpiling is a good option. A good test case is ~:-.(~:/+.)(~:/+.())~:-. with expected output 0 0
Try it online!

276 bytes

Runic Enchantments, 266 264 bytes
DS͗{r;'ui[0[0y̤<<<<<?+f2,;$"!0/"?*7≠0:S͗\
RS͗}:'~=?!\:':=?!\:'+=?!\:'-=?!\:'/=?!/:'.=?!\:'*=?!\:';=?!;:')≠3*?04B͍:'(=?!S͗
U/lA`R耀`S͗/?7  :S͗/?+f1+S͗/?3  -S͗/?3     $ '$:S͗/?7  *S͗/
U\m(d*?"SO!"$;
{:'(=?!\:')=?!\R
~/?)0l{͗/?8 {͗l}͗/U
 \}͗21B͍

Try it online!
Due to limitations built into Runic, it can only support program lengths (and stack size) of ~501. Programs that are too large will simply fail. If the stack grows too large, it will error with SO! (wasn't required, but was better than silent termination; cost 24 bytes). If the program attempts to divide by 0, it will print /0!.
Errors are appended to the end of standard output as Runic has no way of writing to STDERR.
This version will support arbitrarily long programs, but is still limited to a stack of ~90 (and thus errors out on the 2nd result of the first test program) and has not been golfed very well (the increase in command length between S͗}: and S͗}͍:0%: required some additional spacing to get sections to line up, but that extra space also allowed for more < for a larger max stack size).
Alternatively, this program will avoid ~ generating a zero and the program will terminate after 1 million execution steps (a safeguard against infinite loops built into the Runic interpreter). Also includes a few bytes to skip over excess NOP space and run a little longer.

Stack oversize fizzling occurrs at (IP mana+10) and the check I put in for Volatile's stack is sizeof(stack) < mana and there are 5 IPs that merge and combine their mana (50 initial). Increasing that value to the true limit (the +10) would cost another 2 bytes and I left the logic golfy instead of accurate.

Explanation

Program begins in the top-center blue area along the <<<<< and the five IPs merge together at the y
IP moves to the left, setting up the stacks and reading input and moves to the cyan section
IP moves to the right down this line checking the top char on the stack for what command it is. This line continues to the right further than is visible. when the correct instruction is found it executes the code on the line below to the left (skipping over other sections to return back to the cyan via the blue).
Magenta section is executed during ~ or : commands to error on Stack Overflow, yellow section is skipped if the stack is not overfull and returns via wraparound to the dark blue.
Far off to the right when the ) is found the program branches to the red section and moves to the right.
This section rotates the command stack to the right until a ( is found (proceed green).
For each additional ) is found (proceed orange), the stack depth stack is bumped and when a ( is found, the stack depth stack is popped once (proceed dark green and orange re-entry)
If the depth stack is empty continue following green to the B and return to cyan to main parsing loop, otherwise wrap via orange->yellow->red (re-entering the loop-reset loop).
The purple in the top right handles division, if the value to divide by is 0, the brown section handles the error and termination. Re-enters main parsing loop by skipping over the cyan section.

Lua, 323 bytes
l,s=load,{}u=l't=...s[#s+1]=t'o=l'n=t s[#s]=_ t=s[#s]return n'math.randomseed(os.time())l((...):gsub('[^-*+/:.()~]',''):gsub('.',{['~']='u(math.random(1e5))',['+']='u(o()+o())',['-']='u(o()-o())',['*']='u(o()*o())',['/']='u(0~=s[#s-1]and o()//o()or-_)',[':']='u(t)',['.']='print(t)',['(']='while 0~=t do ',[')']='end '}))()

Try it online!
Transpiles the Volatile code into Lua. Note that s represents the stack itself, u pushes onto the stack, o pops off the stack, and t represents the value at the top of the stack.

Volatile
Lua

~
u(math.random(1e5))

+
u(o()+o())

-
u(o()-o())

*
u(o()*o())

/
u(0~=s[#s-1]and o()//o()or-_)

:
u(t)

.
print(t)

(
while 0~=t do

)
end

PHP, 196 bytes
eval(strtr($argn,[':'=>($v='$a[]=').$e='end($a);','~'=>$v.'rand();','+'=>($q=$v.$p='array_pop($a)')."+$p;",'-'=>"$q-$p;",'*'=>"$q*$p;",'/'=>"$q/$p;",'.'=>"echo' ',$e",'('=>"for(;$e){",')'=>'}']));

Input 1: Try it online!
Input 2 (0, 1, 2, ...): Try it online!
Input 3 (Division by zero error): Try it online!
Just translates the code to PHP and evaluates it!

Java 8, 420 418 402 373 359 357 341 339 bytes
import java.util.*;s->f(s,new Stack());void f(String s,Stack<Integer>S){for(int i=0,c,t,u;i<s.length();){if((c=s.charAt(i++))<42&&S.peek()!=0)f(s.substring(40/c*i),S);if(c==46)System.out.println(S.peek());if(c>57)S.add(c>99?new Random().nextInt():S.peek());if(c<44|c==45|c==47){t=S.pop();u=S.pop();S.add(c<43?u*t:c<45?u+t:c<46?u-t:u/t);}}}

-2 bytes thanks to @Grimy.
-18 bytes thanks to @ceilingcat.
Try it online.
Explanation:
import java.util.*;       // Required import for 2x Stack and Random

s->                       // Method with String parameter and no return-type
  f(s,new Stack())        //  Call the recursive function, with a new Stack

// Separated recursive method with String and Stack parameters
void f(String s,Stack<Integer>S){
  int i=0,                //  Index integer
      c,                  //  Temp integer used for the current character
      t,u;                //  Temp integers used for the peeked/popped top of the stack
  for(;i<s.length();){    //  Loop `i` in the range [0, String-length):
    if((c=s.charAt(i      //   Set `c` to the current character
                    ++))  //   And increase index `i` by 1 right after
        <42               //   If the character is either '(' or ')',
        &&S.peek()!=0)    //   and the top of the stack is not 0:
         f(s.substring(   //    Take the substring, either removing everything before and
            40/c*i),      //    including the "(", or keeping the string as is for ")"
           S);            //    And do a recursive call with this String
    if(c==46)             //    If the character is '.'
      System.out.println( //     Print with trailing newline:
       S.peek());         //      The peeked top of the stack
    if(c>57)              //    If the character is ':' or '~':
      S.add(c>99?         //     If the character is '~':
        new Random().nextInt()
                          //      Add a random [0,2147483647) integer to the stack
       :                  //     Else (the character is ':')
        S.peek());        //      Add the peeked top to the stack
    if(c<44|c==45|c==47)  //    If the character is '*', '+', '-', or '/':
      t=S.pop();u=S.pop();//    Pop and set the top two values to `t` and `u`
      S.add(c<43?         //     If the character is '*':
        u*t               //      Add the product of the two values to the stack
       :c<44?             //     Else-if the character is '+':
        u+t               //      Add the sum of the two values to the stack
       :c<46?             //     Else-if the character is '-':
        u-t               //      Subtract the top two values, and add it to the stack
       :                  //     Else (the character is '/'):
        u/t;}}}           //      Divide the top two values, and add it to the stack

new Random().nextInt() is 2 shorter than (int)(Math.random()*1e5).

@Grimy Ah, forgot I had that java.util.* import for the Stack. Thanks! :)

@ceilingcat Thanks for -16!

This probably goes against one or more rules of decorum but if you replace new Random().nextInt() with 5 all testcases still pass.

@ceilingcat Yeah, but 5 isn't exactly random ;) Relevant xkcd

JavaScript (V8),  178 172  171 bytes
Transpiles to JS. May throw either Z is not defined or x is not defined if the code attempts to do something bad.
s=>eval(s.replace(/./g,c=>`S.push(${c>'}'?'x=Math.random()*1e5|0':c>'9'?'x':c=='.'?');print(x':c<')'?');while(x){(0':c<'*'?')}(0':`1/(x${c}=S.pop(S.pop()))?x:Z`});`,S=[]))

Try the 1st program online!
Try the 2nd program online!
Try the 3rd program online!
How?
Each instruction is transpiled to S.push(, followed by a specific pattern, followed by );.
We have to test the division by zero explicitly because JS doesn't give the slightest damn about such a harmless operation. :-p

 char. | JS code
-------+--------------------------------------
   ~   | S.push( x=Math.random()*1e5|0 );
   +   | S.push( 1/(x+=S.pop(S.pop()))?x:Z );
   -   | S.push( 1/(x-=S.pop(S.pop()))?x:Z );
   *   | S.push( 1/(x*=S.pop(S.pop()))?x:Z );
   /   | S.push( 1/(x/=S.pop(S.pop()))?x:Z );
   :   | S.push( x );
   .   | S.push( );print(x );
   (   | S.push( );while(x){(0 );
   )   | S.push( )}(0 );

C (gcc) for Linux x86_64, 675 643 621 613 597 432 404 399 bytes
printf();*z;*mmap();(*p)();*j(char*a){char*t=a,*n,c;for(p=0;read(0,&c,!p);t=!~c?n=j(t+9),z=mempcpy(t,L"\xf00f883Ƅ",5),*z=n-t-9,n:!c?p=*t++=233,z=t,*z=a-13-t,z+1:stpcpy(t,c-85?c-2?c-4?c-1?c-6?c-17?"PAPTYh%ld T_P^1\xc0QH\x83\xcc\bQA\xff\xd0\\AXX":"P":L"\xfef7995e":"[\xf7\xeb":"[)\xd8":"[\1\xd8":L"\xf0c70f50"))c-=41;return t;}main(){p=mmap(0,1<<20,6,34,0,0);p(strcpy(j(p),"j<X\xf\5"),0,0,0,printf);}

Try it online!
This is a JIT that directly translates Volatile instructions into x86_64 machine language and executes the code. If your machine doesn't have the rdrand instruction, you can replace L"\xf0c70f50" with "Pj*X" for a "less uniform PRNG". To port to something other than Linux, replace the syscalls in the printf() and exit() blobs and adjust parameters to mmap().
EDIT: This version calls printf() instead of implementing a subset from scratch.
EDIT2: Supported integers are now 32 bits instead of 64.
Slightly less golfed...
printf();*z;*mmap();(*p)();
// recursive function translates Volatile commands to x86_64 instructions
*j(char*a){
  char*t=a,*n,c;
  for(p=0;read(0,&c,!p);)
    c-=41,
    t=c=='('+41?
      // cmp eax,0
      // je n-t-9
      n=j(t+9),
      z=mempcpy(t,"\x83\xf8\x00\x0f\x84",5),
      *z=n-t-9,
      n
    :
      c==')'+41?
        // jmp a-13-t
        p=*t++=233,
        z=t,
        *z=a-13-t,
        z+1
      :
        stpcpy(t,c-'~'+41?
                   c-'+'+41?
                     c-'-'+41?
                       c-'*'+41?
                         c-'/'+41?
                           c-':'+41?
                             // ; This calls printf("%ld ",%rax)
                             // push rax
                             // push r8
                             // push rsp
                             // pop  rcx
                             // push 0x20646c25
                             // push rsp
                             // pop  rdi
                             // push rax
                             // pop  rsi
                             // xor  eax, eax
                             // push rcx
                             // or   rsp, 8
                             // push rcx
                             // call r8
                             // pop  rsp
                             // pop  r8
                             // pop  rax
                             "\x50\x41\x50\x54\x59\x68\x25\x6c\x64\x20\x54\x5f\x50\x5e\x31\xc0\x51\x48\x83\xcc\x08\x51\x41\xff\xd0\x5c\x41\x58\x58"
                           :
                             // push rax
                             "\x50"
                         :
                           // pop rsi
                           // cdq
                           // idiv esi
                           "\x5e\x99\xf7\xfe"
                       :
                         // pop rbx
                         // imul ebx
                         "\x5b\xf7\xeb"
                     :
                       // pop rbx
                       // sub eax, ebx
                       "\x5b\x29\xd8"
                   :
                     // pop rbx
                     // add eax, ebx
                     "\x5b\x01\xd8"
                 :
                   // push rax
                   // rdrand eax
                   "\x50\x0f\xc7\xf0");
  return t;
}
main(){
  p=mmap(0,1<<20,6,34,0,0);
  p(strcpy(j(p),"\x6a\x3c\x58\x0f\x05"),0,0,0,printf);
}

Python 2, 460 454 428 417 413 412 406 bytes
from random import*
a=raw_input();i=v=0;s=[];o='p(s.pop()%ss.pop())';l=len;p=s.append
def L(u,c,N,r):
 u=u[::r];f=0
 for i in range(l(u)):
    if c==u[i]:f+=1
    if f==N:return l(u)-i+l(u)*(r>0)
while i<l(a):c=a[i];exec['v+=1;'+'i=L(a,")",v,1)'*(c=='('and not s[-1]),'i=L(a,"(",v,-1)-1'if')'==c and s[-1]else'v-=1','p(randint(0,4e4))','p(s[-1])','print(int(s[-1]))',o%c,o%c,o%c,o%c,'']['()~:.+-*/'.find(c)];i+=1

Try it online!
Try it ungolfed!
-19 bytes thanks to emanresu
-26 bytes thanks to implicit loop errors
-2 bytes because -1 wraps to the end of the array
-1 byte by moving operators into main array
-6 bytes by fitting everything into the exec array
Transpiles to Python code.
Explanation
from random import*

We need this for access to randint, and of course importing everything is golfier than just importing randint
a=raw_input();i=v=0;s=[];o='p(s.pop()%ss.pop())';l=len;p=s.append

This defines a few initial variables.
a is the source code, read from STDIN
i is the instruction pointer, ie the index of the current character in source
v is used to track nested loops
s is the stack
o is a string template used for the four operators, they're all the same logic just with a different operator, and that operator is conveniently also the instruction that triggers it, so we can just interpolate the char into this string
l and p are just short aliases to save bytes on repeated functions
;l=len costs 6 bytes, but saves 2 on each call to len, so as long as we use len more than 3 times in the program, we save bytes.
;p=s.append costs 11 bytes, but saves 7 on each push to the stack, meaning it's worth it even if we only push twice.
def L(u,c,N,r):
 u=u[::r];f=0
 for i in range(l(u)):
    if c==u[i]:f+=1
    if f==N:return l(u)-i+l(u)*(r>0)

This function is used to find the opposite end of a loop while considering nested loops. u is the source code, c is the char to find, N is the nest depth, and r is the direction. Returns the index of the first char after the found character.
If for any reason this function can't find a matching end of the loop, it returns None, which then throws an error on the next iteration of the main while loop.
while i<l(a):c=a[i];exec['v+=1;'+'i=L(a,")",v,1)'*(c=='('and not s[-1]),'i=L(a,"(",v,-1)-1'if')'==c and s[-1]else'v-=1','p(randint(0,4e4))','p(s[-1])','print(int(s[-1]))',o%c,o%c,o%c,o%c,'']['()~:.+-*/'.find(c)];i+=1

This is the main parsing loop
while i<l(a):

Keep looping while the instruction pointer has not reached the end of the code
 c=a[i]

This is setup for each individual character.
c is the current character, ie the character at index i in the source code
 exec['v+=1;'+'i=L(a,")",v,1)'*(c=='('and not s[-1]),'i=L(a,"(",v,-1)-1'if')'==c and s[-1]else'v-=1','p(randint(0,4e4))','p(s[-1])','print(int(s[-1]))',o%c,o%c,o%c,o%c,'']['()~:.+-*/'.find(c)]

Finally, we get the index of c in the string '()~:.+-*/'. ie 0 for (, 1 for ), 2 for ~, 3 for :, 4 for ., 5-8 for an operator, and -1 for anything else, and then use that to index into this array with  to get the relevant code to execute. As indexing with -1 in Python wraps to the end of the array, -1 will return '' here.
'v+=1;'+'i=L(a,")",v,1)'*(c=='('and not s[-1])

The transpiled code for ( increments v and, if the top of the stack is falsey, moves the instruction pointer to the end of the loop. We have to check that c=='(' so that s[-1] is not being evaluated on every instruction, causing an error when the program first starts and the stack is empty.
'i=L(a,"(",v,-1)-1'if')'==c and s[-1]else'v-=1'

The transpiled code for ) jumps to the beginning of the loop if the top of the stack is truthy, or otherwise decrements v. Again we have to check that ')'==c first to prevent s[-1] incorrectly evaluating on an empty stack.
p(randint(0,4e4))

The transpiled code for ~ pushes a random value between 0 and 40,000 (inclusive). 4e4 was the smallest 3-byte expression I found that was greater than or equal to the required max of 32,768, because 2**15 is still 5 bytes. Unfortunately I don't think it's possible to create a number large enough in fewer bytes.
p(s[-1])

The transpiled code for : simply pushes the top of the stack to the stack.
print(int(s[-1]))

The transpiled code for . prints the top of the stack with a trailing newline. Unfortunately we have to cast to an int costing 5 bytes as otherwise every value that's touched division will be printed with a trailing .0
o%c

The transpiled code for operators is the operator template o interpolated with the operator. ie:
p(s.pop()Xs.pop())

Where X is whatever character (one of +-*/) we're currently on.
We then exec the result of this indexing, running the transpiled code for the current instruction.
;i+=1

Last but not least, we increment i and repeat the loop.

If your PRNG has a very low variance (say, return 2 all the time) you may be able to omit the import.

@ceilingcat I'm not sure what you mean, the random module is the only method I'm aware of to generate reasonably uniformly random numbers in python

A "random number generator" that only returns 2 should pass all test cases.

@ceilingcat That is not random

PowerShell Core, 176 bytes
for($k=0;$c=$args[$k++]){switch -r($c){~{$t=,((get-random)%32768)+$t}'[-+*/]'{$a,$b,$t=$t
$t=,("$a$c $b"|iex)+$t}:{$t=,$t[0]+$t}'\.'{$t[0]}'\('{$l=$k-1}'\)'{if($t[0]){$k=$l}}}}

Try it online!
This is a special version that stops after a few iterations to validate the loop's behaviour: Try it online!
I saved about 50 bytes by faking a stack using arrays concatenation and deconstruction:

$a,$t=$t to pop values
$t=,$a+$t to push values

Kotlin, 412 bytes
Unfortunately I lost to Java, but I didn't want to import java.util.Stack (and I'm not sure it would close the gap anyway.)
{p->var i=0
var s=List(0){0}
var c=List(0){0}
while(i
s+=(0..32768).random()
in "+-*/"->{val(a,b)=s.takeLast(2)
s=s.dropLast(2)+when(o){'+'->a+b
'-'->a-b
'*'->a*b
'/'->a/b
else->0}}
':'->s+=s.last()
'.'->println(s.last())
'('->{if(s.last()!=0)c+=i else{var z=0
do{if(p[i]=='(')z++else if(p[i]==')')z--
i++}while(z>0)
i--}}
')'->if(s.last()!=0)i=c.last()else c=c.dropLast(1)}
i++}}

Ungolfed
{ p ->                  // open lambda: p is the code string
    var i = 0           // program counter
    var s = List(0){0}  // data stack
    var c = List(0){0}  // jump stack

    // main loop
    while(i
 s += (0..32768).random()
            // if a math op...
            in "+-*/" -> {
                // pick top stack items
                val (a, b) = s.takeLast(2)
                // pop two items and then push based on op
                s = s.dropLast(2) + when(o) {
                    '+' -> a+b
                    '-' -> a-b
                    '*' -> a*b
                    '/' -> a/b
                    else -> 0  // else is required here
                }
            }
            // duplicate top stack item
            ':' -> s += s.last()
            // print top stack item
            '.' -> println(s.last())
            // open loop
            '(' -> {
                if(s.last()!=0)
                    // push to jump stack if top of data stack is nonzero
                    c+=i
                else {
                    // skip ahead
                    var z=0
                    do {
                        // seek to matching brace
                        if(p[i]=='(') z++ else if(p[i]==')') z--
                        i++
                    } while(z>0)
                    // ensure program counter doesn't go too far
                    i--
                }
            }
            // close loop
            ')' -> if(s.last()!=0) i=c.last() else c=c.dropLast(1)
        }
        // next character
        i++
    }
}

Try it online!

Go, 660 bytes, fixed seed
import."math/rand"
func f(C string){for i,S,P:=0,[]uint{},[]int{};i<len(C);i++{if c:=C[i];c=='~'{
S=append(S,uint(Int()))}else if c=='+'{b:=S[len(S)-1];S=S[:len(S)-1];a:=S[len(S)-1];S=S[:len(S)-1];S=append(S,a+b)}else if c=='-'{
b:=S[len(S)-1]
S=S[:len(S)-1]
a:=S[len(S)-1]
S=S[:len(S)-1]
S=append(S,a-b)}else if c=='*'{b:=S[len(S)-1]
S=S[:len(S)-1]
a:=S[len(S)-1]
S=S[:len(S)-1]
S=append(S,a*b)}else if c=='/'{b:=S[len(S)-1]
S=S[:len(S)-1]
a:=S[len(S)-1]
S=S[:len(S)-1]
S=append(S,a/b)}else if c==':'{S=append(S,S[len(S)-1])}else if c=='.'{println(S[len(S)-1])}else if c=='('{P=append(P,i)}else if c==')'{if S[len(S)-1]<1{i=P[len(P)-1]}else{P=P[:len(P)-1]}}}}

Attempt This Online!
confirmed go worse than java
Most of this is handling the pops. The title has "fixed seed" because in Go, the random number generator starts with the same fixed seed, every time. You need to seed it with some changing value for it to be truly random (+29 bytes):
Go, 689 bytes, truly random
import(."math/rand";."time")
func f(C string){Seed(Now().Unix())
for i,S,P:=0,[]uint{},[]int{};i<len(C);i++{if c:=C[i];c=='~'{
S=append(S,uint(Int()))}else if c=='+'{b:=S[len(S)-1];S=S[:len(S)-1];a:=S[len(S)-1];S=S[:len(S)-1];S=append(S,a+b)}else if c=='-'{
b:=S[len(S)-1]
S=S[:len(S)-1]
a:=S[len(S)-1]
S=S[:len(S)-1]
S=append(S,a-b)}else if c=='*'{b:=S[len(S)-1]
S=S[:len(S)-1]
a:=S[len(S)-1]
S=S[:len(S)-1]
S=append(S,a*b)}else if c=='/'{b:=S[len(S)-1]
S=S[:len(S)-1]
a:=S[len(S)-1]
S=S[:len(S)-1]
S=append(S,a/b)}else if c==':'{S=append(S,S[len(S)-1])}else if c=='.'{println(S[len(S)-1])}else if c=='('{P=append(P,i)}else if c==')'{if S[len(S)-1]<1{i=P[len(P)-1]}else{P=P[:len(P)-1]}}}}

Attempt This Online!

Vyxal D, 215 bitsv1, 26.875 bytes
`~.(/``kεʀ℅`\…‛{:|`:0=ß•/`WḣĿ∑Ė

Try it Online!
Translates volatile to its vyxal equivalent (which is almost 1 to 1, given that volatile is a subset of Keg which is a subset of Vyxal).


text:
Wrong keyboard position
You are in fact writing an interpreter for the language "Wrong keyboard position". You can pretend that you are not doing this and just follow the instructions below.

I typr re;atively accuratrly, but so,etimes I made a whole nlock of text illegible by shifting a key right. So I need a program that corrects my text back to its original meaning.
Rules

You have to left shift on a standard English QWERTY keyboard.
Whitespace do not count for the procedure before left-shifting and are kept as-is in a standard left-shifting procedure. If the key is the leftmost letter/symbol on a keyboard(i.e. The ~key, Q key, A key, Z key.), the key is kept as-is. If you reach a control character while left-shifting (Caps lock and Shift), their effects will not be triggered and the character before left-shifting is kept.
This is a code-golf contest; the shortest answer wins.
Both the input and the output shall be given via our default methods.

Representation of a subset of the QWERTY keyboard that you will need
The two lines connected are possible values of the key: shifted/unshifted.
~!@#$%^&*()_+
`1234567890-=

QWERTYUIOP{}|
qwertyuiop[]\

ASDFGHJKL:"
asdfghjkl;'

ZXCVBNM<>?
zxcvbnm,./

(Space)
(Space)

Input
The input will always be a non-empty string conforming the rules above.
Output
The output will be the input string corrected to the originally intended meaning.
Examples:
Yjod ,sfr yjr, imjsppu/ -> This made them unhaooy.
vpfr hp;g -> code golf

Test case fixed.

I ported my solution with almost no change, so I'm gonna agree with the duplicate vote.

05AB1E, 59 bytes
-1 byte thanks to Kevin Cruijssen
žVDu«1ú`žhÀ“~!@#$%^&*()_+ `ÿ-=ÿ<>?ÿ:"ÿ{}|ÿ,./ÿ;'ÿ[]\“#vy¦y‡

Try it online!

-1 using žhÀ instead of 9LJ, so the 0 inside the string can be removed (same applies to your other answer)

@KevinCruijssen updated both, thanks!


text:
Double it your way
There have been a couple of challenges involving doubling source code: here and here. The task we have here is a bit harder, but should be doable in almost every language.
In this challenge, you will take in an arbitrary positive integer. Your program must output that integer doubled.
When your source code is doubled, it will take in a positive integer, and output it squared.
How is your source code doubled? Well, you can have it your way.
That is to say, you can split your source code up into strings of bytes or characters (or tokens in tokenized langs) of any equal length you want, and repeat each chunk twice in succession.
For an initial program of ABCDEFGHIJKL, (length 12) here are all possible doubled programs:
Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

Note that this means programs of prime lengths can only be doubled two ways: every character doubled, or the full program is repeated twice.
Rules:

Code must be a full program or function.
Standard loopholes are forbidden.
Standard I/O methods are allowed.
All characters/bytes, including whitespace and newlines, are counted in the length of the code and contribute to chunks.
You may assume that the input and its square can be represented by your language's int/integer type.
You may not assume a trailing newline or other character.
Provide your chunk size in the heading after the byte count.
This is code-golf, so shorter programs are better! If two programs are the same length, the one which uses the smaller chunk length wins. (If you have a longer program which uses a smaller chunk length, that is worth posting too!)
If your program requires a second input/line, you may make no assumptions on its value. In particular, your program should work if the second input is empty, the same as the first, or a different integer. If your program does not require a second input/line, you may ignore this restriction.

Sandbox link

Can I output result as float (with .0 at the end)?

May we print the square twice when the code is doubled? Single code: 5 -> 10; double code: 5 -> 25 25.

@RobinRyder No, you may not.

@val You may output as float.

Perl 5, 8 bytes (chunk size 4)
$_*=~~+2

Try it online, or try the doubled version.
Unary ~ is the bitwise negate, so applying it twice is a noop. Thus, the base program simply multiplies $_ (the implicit input-output variable) by 2.
Binary ~~ is smartmatch, which returns a boolean. ~~+2~~+2 parses as (~~+2) ~~ (+2). Since 2 equals 2, this yields true (1). Thus, the doubled program first multiplies $_ by 1, then multiplies $_ by itself.

05AB1E, 4 bytes (chunk size 2 or 4)
·Inr

Try it online or doubled as a single 4-byte chunk or doubled as two 2-byte chunks.
·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3, 26 bytes (chunk size 13)
lambda n:"and n*n#"and 2*n

Try it online!
Doubled:
lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

This solution is provided by @Grimy.

Python 3, 32 30 28 bytes (chunk size 16 15 14)
lambda n:bool(0)*n*n or  2*n

Try it online!
-4 bytes thanks to @negativeSeven
Doubled:
lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

Try it online!
The function takes advantage of the unique chunk rule of this challenge.

26: TIO

@Grimy Nice approach. I think it is different enough and deserves its own post.

@Grimy I added your solution to my post since you do not seem to be interested in making a separate post.

Hexagony, 14 bytes (chunk size 14)
?"+==*/}=+!@!<

Expanded:
  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

Try it online!
Doubled
?"+==*/}=+!@!<?"+==*/}=+!@!<

Expanded:
   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

Try it doubled online!
Hexagony is in a bit of a weird position in this challenge, in that actually achieving the task is not much more difficult than simply being able to write the two individual programs. However, golfing the solution proved rather difficult.
This solution is the trivial idea in the shortest form that I could fit, but I suspect there are shorter, cleverer answers. This version very naively sets two values to the input and sums them or multiplies them, depending on if the source is doubled. The only code reuse is the "+ which makes making the copy code for the doubled program short enough to fit in the unused space from the original program.
I suspect using the IP change instructions [] will make isolating the parts easier, but a truly ideal solution will reuse a lot of code between the two. I made a helper program to double hexagony source code. Note that it removes trailing no-ops so if you want to have placeholder no-ops at the end just fill in some other character and change it back after. It can handle different chunk sizes, though I didn't yet write code to output each possible program (Hexagony seems to lend itself to using the full chunk size).

@JoKing Well done! It's rather different from my answer, so would you want to post it (using the different chunk size to fill up unused space is really neat!)? Otherwise I'll add it and an explanation when I have more time.

Befunge-98 (FBBI), 8 bytes (chunk length 2)
;&:#* +q

Try it online!
;&;&:#:#* * +q+q

Try it online! (doubled)
Excluding control flow, the first program executes &:+q (input, duplicate top of stack, add, exit with return code), and the second executes &:*+q (input, duplicate top of stack, multiply, add (sums with an implicit 0), exit with return code)

Hexagony, 12 bytes (chunk size 4)
?"2+...}=*!@

Try it online!
Formatted:
  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

And doubled, then formatted:
   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

Basically, this sets the first edge to the input, then the second edge to either 2 or a copy of the input, then multiplies those two edges into the third edge, prints that and terminates. The list of executed instructions are just
?"2}=*!@

and
?"2+}=*!@

With the only difference being the + overriding the 2 on the second program.

JavaScript (ES6),  24  22 bytes
Despite its unusual format, this is the definition of an anonymous function, which can be either called directly or assigned to a variable.
+(g=x=>x*x)?g:(x=>x*2)

Try it online!
+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

Try it online doubled!
How?
Applying the unary + to a function is interpreted as an attempt to coerce it to a number and results in NaN. Therefore, the leading +(g=x=>x*x) is falsy in both versions.
On the other hand, applying the binary + between 2 functions results in a string. Therefore, (x=>x*2)+(g=x=>x*x) is truthy in the doubled version.

Dude, have you noticed that this can be split in chunks of 11, too?

Perl 6, 8 bytes (chunk size 1)
* *<1 2>

Try it online! Try it doubled!
A Whatever/HyperWhatever lambda that takes a number and returns a number for the first program and a singleton list for the second program. Basically this keeps the exact same logic, except that the multiplication operator (*) is replaced by the exponential one (**).
**  **<<11  22>>

The Whatever literal (confusingly also represented by a *) are doubled up to a HyperWhatever (**) which is basically the same except it maps over lists. The space is needed to separate the Whatever literal from the multiplication and is ignored when doubled up. Instead of just 2 (which would get doubled to 22) we use a list containing two elements, which evaluates to 2 in a numeric context). The <> can be doubled to a list with interpolation, and the two elements inside are doubled, but neither of those change the length of the list.

Runic Enchantments, 9 bytes (chunk size 3)
i3?:*@:+@

Try it online!
Try it doubled!
The 3? skips the next 3 instructions, resulting in an (executed) i3?...:+@. When doubled it results in an executed i3?...:*@ where . represents the 3 NOP'd instructions. @ is "print entire stack and terminate."

C# (Visual C# Interactive Compiler) / Javascript, 22 bytes, chunk size 11
m=>/*      /2*m//*/m*2

Try it online!

Also works in JavaScript

Also works in Java by changing the = to -. Nice answer!

I like how the comment actually describes what the code does. :p

Brain-Flak, 76 bytes, 76 byte chunks
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

Try it online!
Doubled (with newline for clarity)
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

Try it online!
Here is a version that uses a more complex doubling procedure.  It does 5 chunks of size 15.  The code here is 46 bytes however due to the required padding it is substantially longer.
105 90 bytes, 15 byte chunks
(              {<><({}()())><><><            <>>({})({}[()])}{}            )<>

Try it online!
Doubled (with newlines for clarity)
(              (
{<><({}()())><>{<><({}()())><>
<><            <><
<>>({})({}[()])<>>({})({}[()])
}{}            }{}
)<>            )<>

Try it online!

Brain-Flak, 48 30 bytes (chunk size 10)
(({}))<>( {({}[()])}{}<>{}{})

Try it online! Try it doubled!
This basically takes three steps, then when doubled executes those steps twice each. The initial program is:

Duplicate TOS, switch stacks and start pushing a value
Get the TOS's triangular number n*(n-1)/2
Pop TOS, switch stack and pop twice, then push the result.

For an input n into an undoubled program, this results in:
1.  Start stack: n n
    Other stack: <
    Third stack:
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

For the doubled program:
1a. Start stack: n n
    Other stack: <
    Third stack:
1b. Start stack: n n <
    Other stack: 0 0
    Third stack:
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack:
    Third stack:

28 bytes (chunk size 7)

Cubix, 18 14 bytes (chunk length 9 7)
*OI$|:/@O+:I.

Note the trailing space. Try it online!
Doubled:
*OI$|:/*OI$|:/@O+:I. @O+:I.

Again, there is one trailing space. Try it online!
Explanation
The main idea is that doubling the code causes the cube to become bigger, so the instruction pointer starts at a different symbol. Since the addition program cannot be put on a cube of side length 1, the side length is going to be 2. Additionally, the doubled code needs to be on a cube of side length 3, so the doubled code must be at least 25 bytes. This means the code must be at least 13 bytes long. As such, at most 1 more byte can be saved.
Now to the actual code. The first observation is that the top face (that is, the first 4 characters) are not used by the addition program. Furthermore, if we make the 5th character reflect the IP around the cube, we can free up 2 more characters. We will use these characters to put the squaring program.

Mornington Crescent, 656 Bytes (Chunk size 328)
Just to add weight to the theory that this can be solved in almost any language...
Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(The trailing newline is important)
Try the single version! ...or... Try the doubled version!

This was a particularly tricky challenge in Mornington Crescent because the program must have such a rigid structure. It's also important to watch where the doubling would take place, because teleporting between stations is illegal in London.
The theory here is simple: In the single version, 'Bounds Green' is filled with a random string, but in the doubled version it gets filled with the squared input. After the chunk ends, both versions double the 'input', but in the doubled version of the code, the input has been replaced with 0.
This result is taken back to Bounds Green, which performs a max() operation twice, before taking the result to the output. In the single version this leaves the doubling unaltered (the int and string are just switched back and forth), but in the doubled version this replaces the 0 with the squared result already stored in Bounds Green.

If my explanation wasn't good enough, I suggest you visit London and try the two routes yourself.

Typo: your chunk size is 328 and not 326. Welcome to CGCC!

Nice spot, thanks!

@JoKing Not sure how I missed that! As it is, I routed it so the 2nd half has no excess chars, and found a way to pad the first half to match without needing extra whitespace. Looks better this way anyway ;)

R, 59 30 bytes (chunk size 59 30)
F=F+1;f=function(n)n*c(2,n)[F]

Try it online!
Credit to Robin Ryder for inspiring this; increments F each time, and the function f selects the appropriate output.
This isn't particularly interesting, but doubtless something clever manipulating the chunk size will be dreamed up. As expected, Robin Ryder came up with this which is both shorter and has some neat chunk manipulation.

JavaScript (Node.js), 15 12 bytes (chunk size: 6)
x=>/**/2*(x)

Try it online!
Single case:
x=>/**/2*(x)

Double case:
x=>/**x=>/**/2*(x)/2*(x)

Seems to also work in C#, and Java if changing => to ->?

R, 42 35 28 bytes (chunk size 4)
Now with a smaller chunk and no error. I also have a longer solution with chunk size 3; see below.
I don't think it is possible to write an R answer with chunk size 1 or 2; I'll happily give a bounty to anyone who proves me wrong.
s =scan#
n=s()#

n/2*4#

Try it online!
The # is for comments in R. The 3rd line is only spaces, making a chunk of newline + 2 spaces + newline, so that the previous and next chunk can have no newline.
Doubled, it becomes:
s =ss =scan#can#
n=s
n=s()# ()#

n/2*n/2*4#  4#

Try it online!
The single version computes \$\frac n2\times4=2n\$; the double version computes \$\frac n2\times \frac n2\times4=n^2\$.
Here is a slightly longer solution, but with chunk size 3:
R, 39 bytes (chunk size 3)
s =bbb=scan#
n=s(#

)#
n* 1/ 2/ 1* 4#

Try it online!
Doubled:
s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#

)# )#
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

Try it online!
Note that Giuseppe has another R answer, with one chunk of 30 bytes.

PowerShell, 22 bytes (chunk size 11)
param($p)
#   /
2 * $p

Try it online.
Doubled:
param($p)
#param($p)
#   /
2 * $p   /
2 * $p

This solution is based on @ShieruAsakoto's solution.
@Grimy solution that has been converted to PowerShell, 26 bytes (chunk size 13)
param($p)$t=';$p*$p#';$p*2

Try it online.
Doubled:
param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Unfortunately you need to have a chunk size that divides your code into equal chunks. As per example in question about prime length solutions.

@JohnRees, i corrected my answer, thanks.

Charcoal, 13 bytes
ＰＩ×Ｉθ⎇υＩθ²⊞υω

Try it online! Explanation: The predefined empty list is falsey so the input is multiplied by 2. When doubled the second pass sees the empty string has been pushed to the list so it multiplies the input by itself instead. Try it online! In verbose syntax this corresponds to Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Java 8, 62 bytes
n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

Chunk length 62.
Try it online or try it online doubled.
Explanation:
n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

In Java, the available comments are // comment and /* comment */. Which are combined here to overwrite certain parts. See how these comments work thanks to the Java highlighting:
n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

The doubled program created a custom Byte class and its value SIZE=9, which overwrites the default java.lang.Byte class and its value SIZE=8.

Japt, 7 5 bytes
*N²jJ

Try it | Doubled
² pushes 2 to the array of inputs N then j removes & returns the element at index J=-1 (i.e., the newly inserted 2) and multiplies the input by that.
When doubled it results in J being multiplied by 2, so the element at index -2 (i.e., the input) is returned by j and used as the multiplier.

Jelly, 8 6 bytes (chunk length 3)
Ḥ;²3ị

Try it online!
Doubled

J, 15 10 9 bytes
+: :(*-:)

Try it online!
Doubled version: Try it online!
f : g creates a verb that executes f when called with one argument, and g when called with 2 arguments.  So ours executes double +: with the original source and *-: when the source is doubled.
This works because a train of two verbs in J becomes a hook, and thus f f is executed as y f (f y) where y is the original input.  Additionally, *-: is itself a "dyadic hook" which works by multiplying * the left arg by half -: the right arg.  The left arg will be the original input, and the right arg will be the input doubled, so this will produce the square of the original input.
original answer
J, 15 bytes
*:@]`(+:@])@.=~

Try it online!
Doubled version: Try it online!
In the single version, we have a single verb which uses Agenda @. to do the if... then logic: If the argument is equal to itself =~, then take the argument and double it (+:@[).
However, when we double the code, we get a J hook.  Call the verb f and the input y.  Then the hook f f executes like this:
y f (f y)

Which means that now the original input is the left arg, and the right arg is the doubled input.  Since these will not be equal, =~ will return false this time, and now we'll execute the other fork of the Agenda, ie, *:@], which means "square the right arg."  And since ~ reverses the inputs of a dyadic verb, the right arg will be the original input.

Nice solution: Lua, 66 bytes (chunk size 66 bytes)
a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

Try it online! (double it yourself, it is not so hard)
Oh yeah, pretty sure that there is shorter solution to this, but it's the best I was able to came up with this way. Take input as first argument.
Brief explanation: whole business with a is quite obvious for everyone, while the second part with x is more interesting. Basically, I create a table (or update existing one on second pass) with finalizer (__gc metamethod) which gets called when program exits.
Lame solution: Lua, 60 bytes (chunk size 30 bytes)
a=a and...^2 or ...*2;                     print(a)os.exit()

Try it online! or Try it doubled!
Smaller and with better chunking, but ultimately boring and lame without any clever tricks. I'm pretty sure no comments are required to this one.

40, chunk size 20

Perl 5 (-p), 22 15 bytes
-7 bytes thanks to Grimy
$_*=$'/4||2;//;

TIO

15: TIO

looking at your solution, I'd just found a 22 bytes solution

understood, first input*=2, then by input*=input/4

another 16 bytes (-a) $_*=/@F/?2:$_/4;

Down to 8 (posted as a separate answer since it's very different).

Python 3, 56 53 bytes
print(eval(input()+"**2"[len(*open(__file__))%2:])) #

My python skills kinda suck, so can definitely be golfed.. Based on the Python answer in the "I double the source, you double the output!" challenge.
Chunk length 53.
Try it online or try it online doubled.

Python 3, 60 bytes
Chunk size 6.
Not a great solution, but it works.
This is such a unique challenge, it really makes you think from a different perspective.
0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

Try it online!
Doubled:

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

Try it online!

Zsh, 30 bytes (chunk size 10)
m=$m[1]*2
x=$[$1$m]
return $x

Try it online! Try it doubled!
Abuses the fact that $var in $[$var] gets expanded first, then evaluated in the arithmetic context.
             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

If anyone wants a crack at lowering this, here's the closest to a 24/8 solution I've gotten (outputs x^2+2 when doubled)

Cascade, 13 bytes (chunk size 13)
]
&/2
#
*
 2&

Try it online!
]
&/2
#
*
 2&]
&/2
#
*
 2&

Try it doubled!
This was quite difficult. The basic gist of this is to print the input multiplied by 2 for the first program, and replace the 2 by a copy of the input for the second.
Explanation:
The executed part of the first program looks like
]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

The doubled program basically adds the first ] to the end of the last line, so the program wraps around to that instead of the &. This turns it into
]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)


text:
Output Distinct Factor Cuboids
Output Distinct Factor Cuboids
Today's task is very simple: given a positive integer, output a representative of each cuboid formable by its factors.
Explanations
A cuboid's volume is the product of its three side lengths. For example, a cuboid of volume 4 whose side lengths are integers can have sides [1, 1, 4], [1, 2, 2], [1, 4, 1], [2, 1, 2], [2, 2, 1], or [4, 1, 1]. However, some of these represent the same cuboid: e.g. [1, 1, 4] and [4, 1, 1] are the same cuboid rotated. There are only two distinct cuboids with volume 4 and integer sides: [1, 1, 4] and [1, 2, 2]. The output can be any representation of the first cuboid, and any representation of the second cuboid.
Input
Your program must take a single positive integer \$1 \le n \le  2^{31}−1\$.
Output
You will need to output all possible cuboids in a list or any other acceptable way. E.g.
Input  Output
  1    [[1, 1, 1]]
  2    [[1, 1, 2]]
  3    [[1, 1, 3]]
  4    [[1, 1, 4], [1, 2, 2]]
  8    [[1, 1, 8], [1, 2, 4], [2, 2, 2]]
 12    [[1, 1, 12], [1, 2, 6], [1, 3, 4], [2, 2, 3]]
 13    [[1, 1, 13]]
 15    [[1, 1, 15], [1, 3, 5]]
 18    [[1, 1, 18], [1, 2, 9], [1, 3, 6], [2, 3, 3]]
 23    [[1, 1, 23]]
 27    [[1, 1, 27], [1, 3, 9], [3, 3, 3]]
 32    [[1, 1, 32], [1, 2, 16], [1, 4, 8], [2, 2, 8], [2, 4, 4]]
 36    [[1, 1, 36], [1, 2, 18], [1, 3, 12],[1, 4, 9], [1, 6, 6], [2, 2, 9], [2, 3, 6], [3, 3, 4]]

Sub-lists don't need to be sorted, just as long as they are unique.
Scoring
This is code golf, so shortest answer in bytes wins. Standard loopholes are forbidden.
Here is a test case generator
Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.
To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, N bytes

where N is the size of your submission. If you improve your score, you can keep old scores in the headline, by striking them through. For instance:
# Ruby, <s>104</s> <s>101</s> 96 bytes

If there you want to include multiple numbers in your header (e.g. because your score is the sum of two files or you want to list interpreter flag penalties separately), make sure that the actual score is the last number in the header:
# Perl, 43 + 2 (-p flag) = 45 bytes

You can also make the language name a link which will then show up in the leaderboard snippet:
# [><>](http://esolangs.org/wiki/Fish), 121 bytes

var QUESTION_ID=192852;
var OVERRIDE_USER=8478;
var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;function answersUrl(d){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(d,e){return"https://api.stackexchange.com/2.2/answers/"+e.join(";")+"/comments?page="+d+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){answers.push.apply(answers,d.items),answers_hash=[],answer_ids=[],d.items.forEach(function(e){e.comments=[];var f=+e.share_link.match(/\d+/);answer_ids.push(f),answers_hash[f]=e}),d.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(d){d.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),d.has_more?getComments():more_answers?getAnswers():process()}})}getAnswers();var SCORE_REG=function(){var d=String.raw`h\d`,e=String.raw`\-?\d+\.?\d*`,f=String.raw`[^\n<>]*`,g=String.raw`<s>${f}</s>|<strike>${f}</strike>|<del>${f}</del>`,h=String.raw`[^\n\d<>]*`,j=String.raw`<[^\n<>]+>`;return new RegExp(String.raw`<${d}>`+String.raw`\s*([^\n,]*[^\s,]),.*?`+String.raw`(${e})`+String.raw`(?=`+String.raw`${h}`+String.raw`(?:(?:${g}|${j})${h})*`+String.raw`</${d}>`+String.raw`)`)}(),OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(d){return d.owner.display_name}function process(){var d=[];answers.forEach(function(n){var o=n.body;n.comments.forEach(function(q){OVERRIDE_REG.test(q.body)&&(o="
"+q.body.replace(OVERRIDE_REG,"")+"
")});var p=o.match(SCORE_REG);p&&d.push({user:getAuthorName(n),size:+p[2],language:p[1],link:n.share_link})}),d.sort(function(n,o){var p=n.size,q=o.size;return p-q});var e={},f=1,g=null,h=1;d.forEach(function(n){n.size!=g&&(h=f),g=n.size,++f;var o=jQuery("#answer-template").html();o=o.replace("{{PLACE}}",h+".").replace("{{NAME}}",n.user).replace("{{LANGUAGE}}",n.language).replace("{{SIZE}}",n.size).replace("{{LINK}}",n.link),o=jQuery(o),jQuery("#answers").append(o);var p=n.language;p=jQuery(""+n.language+"").text().toLowerCase(),e[p]=e[p]||{lang:n.language,user:n.user,size:n.size,link:n.link,uniq:p}});var j=[];for(var k in e)e.hasOwnProperty(k)&&j.push(e[k]);j.sort(function(n,o){return n.uniq>o.uniq?1:n.uniq<o.uniq?-1:0});for(var l=0;l<j.length;++l){var m=jQuery("#language-template").html(),k=j[l];m=m.replace("{{LANGUAGE}}",k.lang).replace("{{NAME}}",k.user).replace("{{SIZE}}",k.size).replace("{{LINK}}",k.link),m=jQuery(m),jQuery("#languages").append(m)}}
body{text-align:left!important}#answer-list{padding:10px;float:left}#language-list{padding:10px;float:left}table thead{font-weight:700}table td{padding:5px}
  <link rel="stylesheet" type="text/css" href="https://cdn.sstatic.net/Sites/codegolf/primary.css?v=f52df912b654">

Winners by Language

Language	User	Score

Leaderboard

	Author	Language	Size

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}

{{LANGUAGE}}	{{NAME}}	{{SIZE}}

Related OEIS sequence.

Related challenge.

Jelly, 7 bytes
œċ3P⁼¥Ƈ

A monadic Link accepting a positive integer which yields a list of 3-lists of positive integers.
Try it online!
How?
œċ3P⁼¥Ƈ - Link: positive integer, N
  3     - literal three
œċ      - all combinations (of [1..N]) of length (3) with replacement
           i.e. [[1,1,1],[1,1,2],...,[1,1,N],[1,2,2],[1,2,3],...,[1,2,N],...,[N,N,N]]
      Ƈ - filter keep those for which:
     ¥  -   last two links as a dyad:
   P    -     product
    ⁼   -     equals (N)?

JavaScript (V8),  61  60 bytes
Prints the cuboids to STDOUT.
n=>{for(z=n;y=z;z--)for(;(x=n/y/z)<=y;y--)x%1||print(x,y,z)}

Try it online!
Commented
n => {                // n = input
  for(                // outer loop:
    z = n;            //   start with z = n
    y = z;            //   set y to z; stop if we've reached 0
    z--               //   decrement z after each iteration
  )                   //
    for(              //   inner loop:
      ;               //     no initialization code
      (x = n / y / z) //     set x to n / y / z
      <= y;           //     stop if x > y
      y--             //     decrement y after each iteration
    )                 //
      x % 1 ||        //     unless x is not an integer,
      print(x, y, z)  //     print the cuboid (x, y, z)
}                     //

Haskell, 52 bytes
f n=[[a,b,c]|a<-[1..n],b<-[1..a],c<-[1..b],a*b*c==n]

Try it online!
Tuples are in descending order. "3" seems to be a small-enough number that writing out the 3 loops was shorter than anything general I could come up with.

I like the meta-obfuscation of calling the returned list's content tuples.

Python 3.8 (pre-release),  83  80 bytes
lambda n:[[i,j,k]for i in(r:=range(n+1))for j in r[i:]for k in r[j:]if i*j*k==n]

Try it online!

...beating a two-loop version by three bytes:
lambda n:[[i,j,n//i//j]for i in(r:=range(1,n+1))for j in r if(i<=j<=n/i/j)>n%(i*j)]

Jelly, 11 bytes
ÆDṗ3Ṣ€QP=¥Ƈ

Try it online!
A monadic link taking an integer as its argument and returning a list of lists of integers.
Explanation
ÆD          | Divisors
  ṗ3        | Cartesian power of 3
    Ṣ€      | Sort each list
      Q     | Unique
         ¥Ƈ | Keep only where the following is true (as a dyad, using the original argument as right argument)
       P    | - Product
        =   | - Is equal (to original argument)

05AB1E, 8 bytes
Ò3.ŒP€{ê

Ò               # prime factors of the input
 3.Œ            # all 3-element partitions
    P           # take the product of each inner list
     €{         # sort each inner list
       ê        # sort and uniquify the outer list

Try it online!

Haskell, 67 60 59 bytes
For a given \$n\$, this produces all 3-tuples of with entries in \$\{1,2,\ldots,n\}\$ and filters out the valid ones. To guarantee uniqueness we require that the tuples are sorted.
f n=[x|x@[a,b,c]<-mapM id$[1..n]<$":-)",a*b*c==n,a<=b,b<=c]

Try it online!

I think three-tuples can only properly be produced with a smiley.

:-)

Retina, 59 bytes
.+
*
2+%L$`(?<=(_+))(?=(\1)*$)
$` _$#2*
A`_(_+) \1\b
_+
$.&

Try it online! Link includes test suite. Explanation:
.+
*

Convert to unary.
2+%L$`(?<=(_+))(?=(\1)*$)
$` _$#2*

Repeating twice, divide the last number on each line into all of its possible pairs of factors. The lookbehind is greedy and atomic, so once it's matched the prefix of the last number it won't backtrack. This generates all possible permutations of three factors.
A`_(_+) \1\b

Delete lines where the factors are not in ascending order.
_+
$.&

Convert to decimal.

C (clang), 89 bytes
a,b,x;f(n){for(a=n;a;a--)for(b=a;b&&(x=n/a/b)<=b;b--)x*b*a-n||printf("%d,%d,%d ",x,b,a);}

Try it online!
Port of @Arnauld
Saved 1 thanks to @Jonathan Frech better output format

"%d %d %d\n" ~> "%d,%d,%d " would save a byte.

Pyth, 11 bytes
fqQ*FT.CSQ3

Try it online!
        SQ  #              range(1, Q+1)          # Q = input
      .C  3 # combinations(             , 3)
f           # filter(lambda T: vvv, ^^^)
 qQ         # Q ==
   *FT      #      fold(__operator_mul, T) ( = product of all elements)

Icon, 87 bytes
procedure f(n)
k:=[]
a:=1to n&b:=1to a&c:=1to b&a*b*c=n&k|||:=[[a,b,c]]&\z
return k
end

Try it online!
Close to Python :)


text:
Floating Point XOR
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.
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.
Shortest code wins.

Welcome to Code Golf! Could you provide some more test cases?

Does Boolean list count as a convenient method?

Why the lenient input format but stringent output format? How about Boolean list as output?

I would say no. I'll edit the question to clarify on what a "convenient method" is.

What if the resulting bit pattern doesn't represent a valid float?

I don't think that's possible...? I just wrote a program to bruteforce 4-byte floats from 0 to UINT_MAX, and it didn't die anywhere. NaN is a valid output, if that's what you're asking.

@virchau With the exactly right input, it should be possible to produce the representation of a sNaN, causing an error.

I found the inputs that work with 8-byte floats (doubles) to produce an sNaN:
1.54234e+260 1.63233e-260
It doesn't throw an FPE on my system, though. Can you try it and see?

That gives me 1.675075421658194e-309.

"binary representation" of a float is extremely ambiguous. You'll need to define which representation you're using. There are an infinite number of representations, including the finite number already used by life on this planet, some being more popular than others, such as IEEE 754

Do we have to handle NaN input?

This question would be more interesting as "xor the values" rather than "xor the representations". The latter is of course identical to "xor two 32-bit integers" in any language that lacks a type system or admits type punning, and thus is pretty boring...

Do we have to handle infinity, subnormals, or negative 0, as either input or output?

@R.., you're assuming 32-bit IEEE-734.  XORing a pair of Microsoft Basic 40-bit floats is a bit more exciting.

@R..: Indeed -- and then of course input and output should be given as exact fractions. (It may be assumed that the input fractions are in lowest terms and the denominators are not powers of two, so the binary representations are unique).

@Mark: No, as written the question is just about xor'ing their representations, whatever those representations are. The result is dependent on the floating point format but the algorithm is always a single xor instruction on the representation, which is pretty boring.

@HenningMakholm: Huh? These are floating point (diadic rationals) not arbitrary rationals. I don't even know what xor would mean on the latter.

@R..: Take their representations as (infinite, repeating) binary fractions, XOR them bit by bit; find out what the result represents?

@HenningMakholm: That's not mathematically meaningful, unlike xor of float values which is addition of polynomials over Z/2Z.

@ReversedEngineer: For languages that support floating point, I think it's implied that you should use the language's native object-representation, whatever that is.  (e.g. something equivalent to type-punning to integer and back).  If the language doesn't support type-punning or XOR of FP data, then you have to implement it yourself using whatever FP representation your chosen implementation uses.

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).

C++ (gcc), 74 32 bytes
#define f(x,y)*(int*)x^=*(int*)y

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!

You can remove the linebreaks to save 2 chars, and this also works in C

You can save 4 more bytes with z=*(int*)x^*(int*)y;.

-2 bytes: using F=float;F f(F*x,F*y){int z=*(int*)x^*(int*)y;return*(F*)&z;}

Function-like macro, 63 bytes: #define f(x,y)[&]{int z=*(int*)x^*(int*)y;return*(float*)&z;}()

With gcc extensions, 54 bytes: #define f(x,y)({int z=*(int*)x^*(int*)y;*(float*)&z;})

Since you're using pointers, is it legal to use one of the inputs as the output? If so, you could write (*(int*)x^=*(int*)y).

62

Taking into consideration @Neil's suggestion it would get to 48 bytes: #define f(x,y)({*(int*)x^=*(int*)y;*(float*)x;})

Actually I've missed the obvious, so another -8 bytes: #define f(x,y)({*(int*)x^=*(int*)y;*x;})

Saves 2 more

37 bytes after merging with @AZTECCO's solution.

Does this work on expressions like f(3.0+1.2,0)?

@PurpleP no because it takes pointers to floats as its arguments.

Note that this is only "safe" in debug mode, or if you use gcc -fno-strict-aliasing.  Maybe you should have specified C++ (MSVC) if you wanted to use type punning via pointer casting.  Although it does work on G++ with optimization disabled.  BTW, this also requires a C++ implementation where sizeof(int) == sizeof(float), so it won't work on G++ for AVR or MSP430 for example.  (TIO runs on x86, which uses 32-bit int and float like all "normal" modern CPUs).

You don't need a comma or GNU C statement-expression here; the golf rules allow returning a value by modifying an input operand by reference.  Also, since this is golf, this version doesn't strictly need the () safety parens.  The "caller" just has to make sure not to use it as part of a larger expression.  It already has lots of other weirdness (like taking args by reference and destroying one of them).

I have a better solution (but it's C-only).

@PeterCordes I think I’ve modified my answer in accordance with this - thanks!

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

Would it be possible to use EORS r0, r1 instead, in order to save 2 bytes? That's only a 2-byte instruction (48 40), compared to your 4-byte EOR. You're already targeting Thumb, so this should work fine, as far as I can see. The only difference is it updates status flags, but you don't care about that side effect in this case.

You should specify that this is using the soft-float ABI which passes FP args in integer registers, not VFP / NEON s0 and s1.

Python 3 + numpy, 75 59 bytes
lambda x,y:(x.view("i")^y.view("i")).view("f")
import numpy

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.

It's shorter than Jelly and Ruby answers. Nice!

You can shave off 27 bytes (dropping it to 48 bytes) by removing the import entirely (just assume the caller passed you numpy.float32s so you can use their methods) and replacing both int32 uses with 'i' and the float32 usage with 'f'; the dtype parameter can be a string which gets converted to the real dtype for you, and conveniently, 'i' and 'f' are legal ways to make those dtypes, which removes the need for the function to import numpy stuff into its namespace at all. Not sure if it's Code Golf legal to remove the import but still assume numpy inputs...

Example showing it works with the import itself being unavailable to f

I thought the imports had to be included, but I’m not sure. Thanks for the tip re the dtypes!

@NickKennedy: Yeah, if the import is required, it only saves 8 bytes (two each from int32 to 'i', four from float32 to 'f'), but that's still something. If the import is strictly required, you could just change it to import numpy to assert the package exists, without using from numpy import* to extract names from it. That would get you another six bytes, down to 61 bytes total.

The f= part can be omitted per rules. Also, the inputs do not have to be converted to arrays, they can just be np.float32 numbers: TIO.

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!
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.

VAX BASIC (later VMS BASIC, then Compaq Basic), 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.

Welcome to the site and nice first answer! I've edited out what appears to be an extraneous header, but if not feel free to edit it back in, along with any accompanying information

APL (Dyalog Unicode), 14 bytesSBCS
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!
⎕ 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) Data Representation (2-row, 64-column matrix)
≠⌿ vertical XOR reduction
645⎕DR convert to 64-bit float (5) Data Representation (single number)

Octave, 59 bytes
@(a,b)(t=@typecast)(bitxor(t(a,u='int32'),t(b,u)),'single')

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.

Bitwise stuff on FP bit patterns is useful in assembly language to do things with the sign bit, or rarely to stuff an integer into the exponent field as part of an exp() implementation.  But I assume Octave already has functions/operators for copysign and negation.  And they don't care about micro-optimizations like using AND (with a constant mask) then XOR to conditionally flip the sign of one value based on the sign of another.  In a real optimization project in asm (actually C with AVX intrinsics) I have used XOR of floats then looking at the sign bit to avoid cmp against zero.

MATL, 10 bytes
4Z%Z}Z~9Z%

Try it online!
Splitting with Z} was shorter than taking two inputs ,4Z%]

Java (JDK), 109 76 63 bytes
a->b->a.intBitsToFloat(a.floatToIntBits(a)^a.floatToIntBits(b))

Try it online!
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!

IIRC you don't even need the assignment as part of the byte count, only as part of any test suite you might include in your Try it online! header.

@Neil Thank you! That makes a big difference!

63 bytes: a->b->a.intBitsToFloat(a.floatToIntBits(a)^a.floatToIntBits(b)). Try it online!

@Unmitigated Thank you! Excellent currying!

C, 23 bytes
f(int*x,int*y){*x^=*y;}

Try it online!
This might be a bit shifty; it takes the pointers to floats as pointers to ints.
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.

JavaScript (Node.js),  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!

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!

FYI Node's Buffer saves a few bytes: a=>(v=new Buffer(4),[x,y]=a.map(n=>v.writeFloatLE(n)&&v.readInt32LE()),v.writeInt32LE(x^y),v.readFloatLE()).

@Neil Thanks! (saved 2 more bytes by using a function instead of map)

Dropping the new in new Buffer(4) should also work iirc

C# (Visual C# Interactive Compiler), 92 bytes
x=>BitConverter.Int32BitsToSingle(x.Aggregate(0,(a,b)=>a^BitConverter.SingleToInt32Bits(b)))

Try it online!

You could use unsafe code for this, though I'm not sure if the "unsafe" keyword should affect the bytecount or not.

Perl 5 -p, 31 27 bytes
-4 bytes thanks to Grimy
$\=unpack f,$a^=pack f,$_}{

Try it online!

Ruby, 78 67 bytes
-11 bytes thanks to @grawity.
->x{[x.pack("gg").unpack("NN").inject(&:^)].pack(?N).unpack(?g)[0]}

Try it online!
Input is an array of two floats.

x.map{|v|[v].pack(?g).unpack(?N)[0]} ⇒ x.pack("gg").unpack("NN")

@grawity: Awesome, thank you very much! The code is still longer than in Python, though. :-/

Lua, 73 bytes
a,b=('II'):unpack(('ff'):pack(...))print((('f'):unpack(('I'):pack(a~b))))

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.

Wolfram Mathematica, 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!

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.

Julia 1.0, 40 bytes
~=reinterpret
!x=Float64~⊻((Int~x)...)

Try it online!
expects Float64s on a 64 bit platform. On a 32 bit platform, use Float32

Clean, 36 bytes
f::!Real!Real->Real
f _ _=code{xor%}

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.

JavaScript (Node.js), 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!
silly

Factor, 40 bytes
[ [ float>bits ] bi@ bitxor bits>float ]

Try it online!
                     ! 2.2 4.4
[ float>bits ] bi@   ! 1074580685 1082969293
bitxor               ! 8388608
bits>float           ! 1.175494350822288e-38