text:
"DDoouubbllee ssppeeaakk!!"
Super simple challenge today, or is it?
I feel like we've heard a fair bit about double speak recently, well let's define it in a codable way...
Double speak is when each and every character in a string of text is immediately repeated. For example:
"DDoouubbllee  ssppeeaakk!!"

The Rules

Write code which accepts one argument, a string.
It will modify this string, duplicating every character.
Then it will return the double speak version of the string.
It's code golf, try to achieve this in the smallest number of bytes.
Please include a link to an online interpreter for your code.
Input strings will only contain characters in the printable ASCII range. Reference: http://www.asciitable.com/mobile/

Leaderboards
Here is a Stack Snippet to generate both a regular leaderboard and an overview of winners by language.

var QUESTION_ID=188988;
var OVERRIDE_USER=53748;
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=asc&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=asc&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}}

To make sure that your answer shows up, please start your answer with a headline, using the following Markdown template:
# Language Name, [Other information] N bytes

where N is the size of your submission. Other information may include flags set and if you've improved your score (usually a struck out number like <s>M</s>). N should be the right-most number in this heading, and everything before the first , is the name of the language you've used. The language name and the word bytes may be links.
For example:
# [><>](http://esolangs.org/wiki/Fish), <s>162</s> 121 [bytes](https://esolangs.org/wiki/Fish#Instructions)

It will modify this string.  Are you intentionally requiring pass-by-reference and modify in-place?  And then return a copy or reference to that modified string?  If so, languages like asm or C would need to accept an explicit-length string (pointer + length) where the length is either the current string length (with the buffer being twice that size), or it's the total size and you need to duplicate the low half.  Thus you need to start from the end and work backwards, or allocate scratch space and then copy back.  But there are answers in C and 8086 asm that totally violate all that.

@PeterCordes I do not care if it modifies the same object or builds a new one.

I'd suggest wording it as "modify (or produce a modified copy) of the string" to explicitly allow answers that do or don't modify in-place.  Simplifying the wording to "return a string that's twice as long, with each character repeated" would be nice but then it's not clear if void foo(char *c, size_t len) is legal that takes one input/output buffer and a length, and doesn't have any return value, just a side-effect on the object it has a pointer to.

@cschultz2048 it says the string will only contain printable ascii characters, so that implies that they’ll always be populated. I’d expect that any code for this challenge would leave an empty string empty... anyway, I don’t think it’s a test case that I’d use for this.

Does this answer your question? Stretching Words Because when you make the two operands in any submission to that challenge equal, programs will obey the behavior described in this challenge. An example of this behavior is here.

@a'_' I'm pretty sure being a subset of another question doesn't make a question a duplicate; otherwise most challenges could be closed as duplicates of, say, "Interpret brainfuck".

@mypronounismonicareinstate I've been known to write challenges which expand on my previous challenges.

Then see this post.

I respectfully disagree.

Malbolge, 20775 and 2334 bytes
Probably I didn't beat anyone with it, but it was incredibly fun to make.
bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPNdchKIeHFbaD_AWV[><X;9U86R53ON1L.DCH+)EDC&;@#>=<;|98x6wu32s0p(',mk)(i&f|{"ca}`^z][wZXtWUqTRnmPNjcbJJ_dcbEDYB@@?ZSX;VUTS6QPO11F..CHGF)(C=<}:98xx/uu,10/po,+$kiih%$#z!b}|{z]xwvXXmUUjonmPOjihafIdcbaD_^]??T<<QVUT76QPONG0..-HGFED=B%@?>=~|438yw5vt21r/o'&+lj(ig%fd"ca}`^z][wZXtWUqpoRQlkjihafIdcbaDBXW\?=YX;9UNMR53O20//DIH+)E>=B%#?"~<}{9zx6wu3tr0/pn,%$jj!&%$ed!~}|{zs\ZZYtsrqponglOjiLgfHdGEaDB^]@[=SRW:8T75Q42N1/K.,HG*E'=<A$"!!6;:{8x0/4us1rp.-,ml)('&%$#z!b}|{zy[qvutsUkTinmlejchKIIH]bE`_^A\[=Y<:VU86RKJO20LK.,HA@E(&BA$">76;|z8yw5vt2sq/pn,mkjj!&%$edy~a|{z][qpuXVUUjonQOkdchKIHH]baD_AWV[><;;PUT7R4JIN1/K.,H+)E(&B%#?"~<}{zz1654ut1*qoon+*#(i&%$e"!~``uzy\ZvonsVTSShmlOjLbafIGFF[`_B@\UTY<:99NSR53OHGL/-I,*F)'C&$@#!=~|:{y765vu21*/pnnm*)(!h%$#d!~}__tyx[vXnmrUSoRPlkNiKa`eHFbECBBW\[>Y;QPU86R53O20L/-I,*F)'&&;@?>!~;:92ywwv3210).o,+*k('g%fd"ca}`^z][wZXtsVqSihmPNjiLgI_^cFD`_B]?UTY<:VUT76QPONGL/--,GFEDC<%@?>!<;:98yw5.-2sq/.o,l$#(ig%fd"!b`|uty\ZYYnsrUpRhglOMiLJfIGcFD`CA]@>==RWVU87RQPONG0..-HGFEDC!<;:zz1ww.321rq.-,+*)"'hffe"!~}|{zyrwZutsVqpoQQfkjMhJ`_dGEaDBAAV[Z=;WPOT75Q4211FKJ-+G@?D'%A$">!};|z8yw5vt210qp-,+*)('&}$e"!~}|^tyxwvXnWlqpohmfkNLLK`IdcbE`_^]\?=YRQV97S64P31ML/J,BAF)'CB%@"87<}{9zx6wu3tr0qo-nlkk"'&%fezcaa`{ty\wvuXsrTpSQmPNjiLJf_^cFD`_B@\UTY<:V97S64P31M0.J-+GFE('B;@#!!~;:3z765v321qq(-,m*j"!&ge#db~}`{]srwZXtWUTTinmPkMcbgJHdGEaDB^A?[><X;988MRQP32MLE.,,+FED=B%@?>!}549zxww.32sq/(',mk)(i&f|{"ca}`^z][wZXtWUqTRnQOkNLhgfIHcbaZ_B@@?ZYXWP9TSR5PON00EJI,*F?>C&$##8=<}:z216wu32s0p(',mk)jh&ge#db~a_{^\x[YuXVUUjonmPOjihg`IdcFa`BAAV[Z=;WPOT75Q42N1/K.,HGF)(CBA@?8=~;:9z76v43tr0)(-nl*)j'g}|#db~a_^^sxwZXtmlqTRnQOkNLhKIeHFbEC_^]@?ZYXWVUN7554ONMLKJIBG*EDC&$:9!!6;:9zy6543210/(o,+*)(h~%$#"bxav{tyxwpuXVVUjoRmlkNihJfIGcFD`CA]@>ZY<:VONS64PO2M/EDI,*F)'C&$@#!=~|:98yx/4u21r/.-mm$)(i&f|{"ca}`^z][wZXtWUqTRnQOkjMhJ`_dGEaDB^A?>>SXWV98SL5332MLEJ-HGF)DC%A@#>~65:{y76w4t,+0qo-,m*j"!&ge#"c~`vuz][wZXtWUqTRnQOkNLhgfIHcb[`C^]\[>YXW99N66KPON10KJIB+))(CBA@9>!<;:9z765uu,10q.n&%*ki'&g$dzy~a_{^\x[YuXVrUSoRPlOMiLJfIGFF[`_^A@[ZYXQV9TSRQ4ON0L/-,,AFE(C%;:?"~<;|z8105vtss*/.o,l$#(ig%fd"ca}`^z][wZXtWUTTinmlONihgfe^GEED_^]\[ZSX;VUT7RQP22GLK.I+A@E(&%%:?>!};438yw5vtss*/.om+$#(ig%$ec!xw|_]y\ZvYWsVTpSQmPNMMbgfeHGba`_^]V[>YX;VUTSR53OHGL/-,,AFE(C%;:?"~<;|9y105vt2sq/pn,mk)jh&ge#db~a_{zy\[vutsrqpiRmlkjiKafedcE[DY^]\UZSX;VUT7RQ322GLK.I+A@E(&BA$">76;|z8yw5vt2sq/pn,mk)jh&geddy~}|_^s\ZZYtmrUponQlkMihKIe^]bEC_^A\>TSX;988MRQ4O1GFK.,HG*E'=!};|z8yw5vt2sqpp',+*kj'~%f#"!b}|^z][wvYWslkpSQPPejiLJf_^cFD`_B]?UTY<:VU8S5KJO20L/-I,*F)'CB%#?87<;:{z76/vtts0/.',m*)(i&%$ddy~}`{]srwZXtWUqpSnPfejMKgJHGG\a`C^@VUZ=;W:8T75Q42N1/K.,++@EDC&%@?>7<}{{z7654-t10/p-,l*ki'&g$dzy~a_{^\x[YuXVrUSoRPlOMiLJII^cbaDC^]\[T=;;:UTSRQJO2MLK.IHGFE(&B;:?"~<}{98y6v.-2sq/pn,mk)jh&ge#db~a_{^\xwvYXsrqpohmPNNMhgfedc\E`_^A\[=YX;9UNMR53O20L/-I,*F)'C&$@#!=~|:{yxx/432sr/.-,+*#jhhg$#"!~}|uz]xwvYtsUqpSnPfejMKgJHdcFaCYX]@>Z=;WV9T6LKP31M0.J-+GF)D&<;@?>!~;:98765.3trrq.-,+*)('~g$#"c~}|{z][wpotWUqTRnQOkNLhgJeG]\aDB^]@[=SRW:8T75Q42N1/..CHGF)(CBA@?>=<5|98765u-210/o'n%*)(!&}$eccbw|_zyx[vuWsVTSShmlOMibafIGFF[`_B]?UTY<:V97S6433HML/-IBAF)'C&$@#!=~|:{y765vu,1r/.-nl$#(igff{"!b}_uty\ZYYnsrUSohglOMiLJfIGcFD`CA]@>Z=;W:877LQPO21LE.,,+FE>C&A@?"=<|{{276wu3,+0qonn%*)j'g}|#db~a_{^\x[YuXVrUSoRPlOMihgJIdc\aD_^]@[Z<XW:U7MLQ42N1/K.,H+)E(&B%#?"~<}{9zxww.321rq.-,%ljji&%$#z!b}|{^yxwYYnsrUSohglOMiLJfeHcE[Z_B@\?=Y<:V97S64P31M0.J-+**?DCB%$?>=<5:{876w432rr).-n+k#"'hf$#d!awv{^\xwZXtmlqTRnQOkNLhKIeHFbEC_B@\?=YXW:9TSRQPI200/JIHGFE>C&A@#!76||3876wv3210/.',m*)j'&%eez!~a_{tsx[YXXmrqTRngfkNLhgJeG]\aDB^A?[><;;PUTS65PONMLKJC,**)DCBA@?>=6;|987x54t21r/o'&+lj(ig%fd"ca``uzy\wYonsVTpSQmPNjMKgfIGc\[`_^A@[ZYXWVUTMR5PONML.DIHGF(>'=6;|98y654tt+0/p-m%$)('hg|eccb}v{^yxwZutVrqToQgfkNLhgJeG]\aDBAAV[Z=X:POT7544INM0.JCBG*(D'%A$">!};|z8yw543ts0).o,+*)j'&%eezbbw|{z]\wvoXVVUponglOjihgJedcEEZ_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{9zx6wutt+0/.on+*)"'h%$#"c~}|^^sxwZuWmlqTRnQOkjMhJ`_dGEaDB^A?[><X;9U86R53ON1L.DCHGF)(CBA@9"~~}:9876/4u210/p-,l*kihh}$#db~wv{^\[[putWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U8655JONM0/JIHGF?D'BA@?"=<;{{2xx/432sr/.-,+*)(!h%$#"!aw|{zy[qZotsrkpinQOONchKfedcFa`B^A?[Z=X:POT7544INM0K-CBG*(D'%A$">!};|z8yw5vtss*/.-nm$)j'&%$e"!a}`^]]rwvYWslkpSQmPNjMKgJHdGEaDB^A?[ZY<;VO8665POHM0KJ-HGFED'%A:9>!}||387x5u-,1rp.-n+k#"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNMhg`eHFFE`_^]V[>YXW:UTS55JON1L.DCH+)E(&BA$?!76;|z8yw54u2r*).om+lj('h%e{z!b`|{z]\wvutmrUponQOediLJII^cbEC_XW\?=Y<:V97S64P31M0.J-+G*(D'%$$9>=<}|98765.ussr/.-,+*#(i&%$e"!~``u]]rwvuXWrqponmfkNihKfeGcFD`CA]@>==RWV9T6LKP31M0.J-+G*(D'%A$">=<}|9876543,s0/p-,lkk"'&ge#zy~a_{^\x[YutWUqjinQONNchgfIHcba`_^]\UZ=XWVUT6LQPON0F/DIHG@E>C&A@#>=<||387x5u-,1rp.om+lj(ig%fd"ca}`^zy\wYonsVTpSQmPNMMbgfeHG\ECCB]V[>YXW:UT6R53O20//DIH+)E>=B%#?>!<|438yw5vt21rp.'&+lj(ig%fd"ca}`^zyx[ZunsVqpoRmlNjiLJf_^cFD`CA]@>Z=;WV9T6LKP31ML/J,BAF)'CB%@"87<}{zz1654ut10)pnnm*)(!&g$#"cawv{^\xwZuWmlqTRnQONNchgJeG]\aDB^]@[=SRW:8T75Q42N1/K.,H+)((=BA@#"=<;49z765v321qq(-,mk)"!&ge#"c~`vuz][wZXWWlqpSQmfejMKgfIGc\[`CA]@>Z=;W:8T75Q42NML/.IHGF?(&&%@?>=<5:{876w432rr).-n+k#"'hf$ec!~a|^tsx[YuXVUUjonQlNdchKIeHFbEC_B@\?=Y<:99NSRQ43NMLKJCH+))(CBA@?>7~;:9z76v43t1q)(-nl*ki'hf$ec!b`|_]y\ZvYWsVTSShmlkNMhgfedc\ECCB]\[ZYXWPU8SRQ4ONMLK.,HA@E(&BA$?!76;|z8yw5vt2sq/pn,mk)jh&ge#db~}|_^yxwvutslqTRRQlkjihgfe^Gba`C^]?[Z=;WPOT75Q42N1/K.,H+)E(&B%#?"~<}{zz1654ut10/.-,+*#j'&%$#cy~}|{]s\qvunsrkpSQQPejMhgfIdcEa`C^@VUZ=;WV9T6LKP31ML/J,BAF)'C&$@#!=~|:{y7xv4usrr).-,ml#(iggf#zc~}|_zy[wZXtsVTpihmPNjMKgfIdF\[`CA]\?Z<RQV97S64P31M0.--BGFE('B;$""!<;49z765v32r0qonn%*)jh&}|#dbaav{z]xZpotWUqTRnQONNchgJHd]\aDB^A?[><X;9U86RQP32MLEJ-++*EDC<%@?>!<;{9zx6wu3tr0qonn%*)j'g}|#db~}`{]srwZXtsVqSihmPNMMbgfIGc\[CCX]\[>=XWVO8665PONMFK.IHG*ED&B%#?>!<|438yw54u2r*).omll#('hf${z!b`|{^y[qpuXVrUSoRPlOMLLafedGFa`_^W\?ZYX;VU7SR5P2HGL/-I,*F)'C&$@#!=~|:{y7xv4usrr).-,ml)('&%|eccb}|{zyxqvYtsrUSihmPNjMKgfIdF\[`CA]@>Z=;WV9T6LKP31M0.J-+G*(''<A@?"!<;:98705v321rp(',mk)jh&%fd"yx}`^z][wZXtsVTpihmPNjMKgJHdGEaDBAAV[ZY<;VUTSRQPI200/JIHGFEDC=~|438yw54u2r*).om+lj(igff{"!b`|uty\ZvYWsVTpSQmPNjMKgfeHGba`_^]\[TY<WVUTS5KPONM/E.CHGF?D=B%@?>!<;{9zx6wu32s0p(',mk)(i&f|{"ca``uzy\wYonsVTpSQPPejiLJf_^cFD`CA]@>Z=;W:8TSR54I200/JCH+FED'BA#?"~<}{98y6v.-2sq/pn,mk)(ig%|{"ca}`^z][wZXtsVqSihmPNMMbgfeHGb[`C^]\?ZY;WV97SLKP31M0.J-+G*(D'%A$">!};|z8ywvv-210qp-,%ljji&%${"c~}|_zy[wvYtVlkpSQmlOjLbafIGcbE`BXW\?=Y<:99NSR5P2HGL/-I,*F)'C&$##8=<;|{876/4u210q.-,ll#('hf${z!b`|{^\xqpuXVrUSonQlNdchKIedGEaZY^A?[><X;9U86R53O20//DIHG*)DCBA:#!!~;:98705v321r/.-mm$)(i&f|{"ca}`^zy\wYonsVTpoRmOediLJII^cbE`BXW\?=YX;V8NMR53O20L/-I,*F)'&&;@?>!~;:98705v321r/.n,mk)jh&ge#"ca}vuz][wZXtsVTpihmPNjMKgJHdGEa`C^@VUZ=;::OTSR54ONMLKJC,**)DCBA@?>7<}:98y65u3tr0qonn%*)j'g}|#db~a_{z]xZpotWUqTRnQOkNLhgJHd]\a`_BA\[ZYXWVOT7RQP3NM/KJ-H*@?D'%A$">!};|z8yw5vt2sq/pn,mkjj!&%$ed!~}|{zyxqZutsrqSinmlkMcLafed]b[`CAA@UZ=XWV9TS544INM0.JCBG*(DC&$@98=~|:{yxx/43tr0)(-nl*ki'hf$ec!b`|{^y[qputsVUjoRmlkNihJII^cbE`BXW\?=<<QVU8S5KJO20LK.I+A@E(&BA$?!76;|z87x5u-,1rp.om+ljii~%$#dc~w`^^]xwpuXsrqTonmOOdihKIe^]bEC_B@\[><XQPU86R5322GLK.,HA@E(&B%#?"~<}{9zx6wutt+0/.on+*#(i&%$e"!a}`^z][wZXtWUqTRnQOkNLhKIedcFE`_^W@>>=XWVUNS6QPO2ML.JI,G)?>&&;@?>!~;:9816w43tr*).omll#('h%e{z!b`|{^y[qpuXVrUSoRPlOMiLJfIGcFD`CA]\[>=XWVUTM6QP3NML..CHG*(D=<A$"!!6;:{y70/4us1rp.om+lj('&gf#"!~}|uz]xwZutVrqToQgfkNLhKIeHFbEC_B@\?=YX;V8NMR53O20L/-IHG*)DCBA@?>7~||{87654321*/p-,+l)('gg|#"ca}vuz][wZXWWlqpSnPfejMKgJHGG\a`C^@VUZ=;WV9T6LKP31MLK.-HGFEDCBA:?"=<;:9y16543s+r).',+*#(i&%$e"!~}|_]yrqvYWsVTSShmlOMibafIGFF[`_B@\UTY<:V97S64P31M0.J-+G*(''<A@?"!6}:9z76vuu,10qo-&%*ki'hf$ec!b`__tyx[vXnmrqpSRmfkNihgJedFbaD_AWV[><XW:U7MLQ4211FKJ-H*@?D'%A$">!};|z8yw5vt2sq/.-nm*)"iggf#"!x}`{z][qpuXVUUjonQlNdchKIedGbDZY^A?[><X;9U86R53O20L/-I,*FED'&A@?8=~;:{876vv-21rp.'&+ljii~%$ec!xw|_]yx[vXnmrUSoRPlOMLLafedGFa`_^W@>>=XWVUTMR5PO2ML.JI,G)?>C&$@#!=~|:{y7xv4us1rp.om+ljii~%$#dc~}|{zsx[YYXsrqpongPkjiLgfeGG\a`C^@VUZ=;W:8T75Q4211FKJ-H*@?D'%A$"!!6;:9zy654321*qoon+*)('&%|#d!~}`{zyxwZXtmlqTRnQONNchgJHd]\aDBAAV[Z=;WPOT75QP31MFEJ-+G*(D'%A$">!};|z876wv3210/.-&+l)(i&%eddy~}`^zsrwZXtWUqTRnQONNchgJeG]\a`_BA\[ZYXWVUN7RQPON0FKJIH*@)>CBA:?8=~||{27x543t10/oo&+*k(h~}$ec!~a|^tsx[YuXVUUjonQlNdchKIedGbDZY^A?[><X;9U86R53O20LKJ-,AF)DC&$:9>!}||387x5u-,1rp.-n+k#"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNMhaJedGba`BBW\[><XQPU8655JON1/KDCH+)E(&B%#?"~<;:{z76/4u21r/.n,+l)i!~%fd"ca}`^z][wZXtWUqpSnPfejMKgJHdGEa`_BA\[ZS<::9TSRQJO2MLK.IH*F)'C&$@#!=~|:{y7xv43t1q)(-nl*ki'hf$#d!awv{^\x[YutsVUponmfkNihgJedFbaD_AWV[><;;PUT75QJIN1/..CHG*(D==~|:327xv4us1rp.om+lj(ig%$#dc~}|{zs\wvYtsUTTinmPNjcbgJHdGEaDB^A?>>SXW:U7MLQPO21LKJIHG@E(CBA$"87}}4987xw43210/.'nllk('&%$#"!x}`{z][qpuXVUUjonQlNdchKIedGbDZY^A?[><X;9U86R53O20L/-I,*FED'&A@?>=<;:38y65432r*/.-,l$k"'&%|#z!b}|_zyxZZotsVTpihmPNMMbgfIGc\[`CA]\?Z<RQV97S64P3100EJIH+*?(&&%@9>!<;|98x65v3s+*/pn,mk)jh&ge#db~a_{^\x[YuXVUUjonmPOjchKIIHcb[D_^]@[Z<XW:8TMLQ42N1/KJ-H*@?D'%A@#>~65:{y7xv4us1rp.om+ljii~%$#dc~}v_]]\wvunsVqpSnmONNchgJHd]\aDB^]@[=SRW:8T75Q42N1/KJ-H*@?D'%A$">=~|:327xvuu,10/po,+*#(iggf#"!~}v{^yx[YonVVkponQPkjihg`eHFFE`_^]\[T=XWV9TS5Q42N1/K.,H+)ED'%A:9>!};|z87x5u-,1rp.om+lj(ig%$e"bxw|_]\\qvutWVqponmleNihKfeGcFDCCX]\?Z<RQV97S64PO20LEDI,*F)'C&$@#!=~|:{yxx/432sr/.-,+*)"'h%$#d!~`|{^y[qpuXVrqToQgfkNLhgJeG]\aDB^A?[><X;9U86R53O20//DIHG*)DCBA@?>=6}:9876v.3210p(o&+*#('~%fddcx}`{z]xwYutWrTjinQOkjMhJ`_dGEa`C^@VUZ=;W:8T75Q42N1/K.,H+)((=BA@#"7<}:9z765uu,10qo-&%*kihh}$#db~wv{^\xwZuWmlqTRnQOkNLKK`edcFE`YB@@?ZYRW:UTS6QP2NM0K-CBG*(DC&A#98=~|{{276wu3,+0qo-nl*ki'hf$ec!b`|_]yxwZYtslqTonQlkjLLafeHcE[Z_^]@?ZYXQ:887RQPOHM0KJI,GF(D'%A$">!};|z8yw54u2r*).om+lj(ig%fdccx}|_z\rqvYWVVkponQPkjihafIdcFDZY^A?>>SXW:U7MLQ42NM0K-CBG*(D'%A$">!};|z8yw5vt2sq/.-nm*)('&}f#"c~}|^^sxwZXtmlqTRQQfkjMKg`_dGEaDB^A?[><XWV98SRQPONGL/--,GFEDCBA:#>=<}:9y7xv4us1rp.om+*k(h~}$ec!b`|_]y\ZvuXVrkjonmPOjihgfed]Fa`C^]\>>SXW:U7MLQPO21LKJIHGFE>C&A@?>=}5:987w/v-210).',m*)(ig}|#db~a_{z][wpotWUqTRQQfkjMKg`_dGEaDB^A?[><X;9U86RQP32G0..-HAF)DC&A@"!!6;:{8x0/4us1rp.-n+k#"'hf$ec!b`|_]y\ZvuXsUkjoRPlOMLLafedGFaZ_B]\?ZYX::OTS64PIHM0.--BGF)'C<;@#!=<}:z216wu3tr0qonn%*)(ih%${dbba|{zsx[vutWrqSonQOkdchKIHH]baD_AWV[><X;988MRQ4O1GFK.,H+)E(&B%#?"~<}{zz1654ut10/(-n+*k('&ff{"!b}_utyxwZYtsrqjSQQPkjihg`eHcbaD_^@??TYX;V8NMR53ON1L.DCH+)E(&BA$?!76;|z87x5u-,1rp.om+lj(ig%$e"bxw|{z]\wvutslqTonmlOjihJJ_GG\a`_BA\[ZYXWVUN7RQPON0FKJIH*@)>CBA:?8=~||{27x5432s0/onn%*)jh&}|#db~}`{]srwZXtWUqTRnQOkNLhKIeHFbEC_B@??TYXW:9NS6QPON1LK-IH+F(>=B%#?"~<;|z8105vt2sq/pn,mk)jh&ge#db~}|_^yr[vutsVqpoQQfNNchgfIHcbaZCAA@[ZYXQV9TSRQ42HGL/-I,*))>CB%@"87<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\[[putsVUponmfkNihgfIdcEaDBAAV[Z=;WPOT75Q42N1/K.,H+)E(&B%#?>=~}:9876/vtts0/.-,+$)j'&ge{z!b`__tyx[vXnmrUSonQlNdchKIeHFbEC_B@\?=Y<:V97S64PON10KJIHGF?D'BA$?>=}}498yw5.-2sqpp',+lj(!~%fd"!b}_uty\ZvYWsVTSShmlkNMhgfedcb[D_^A\[Z<<Q99NSRQ43NMLKJIHG@E(CBA@?!7<;:9y1x/43,10).o,+l)('gg|ddy~}|_^s\ZZYtmrUponQlkjihKIe^]bEC_^A?[TSX;9U86RQ42NGFK.,H+)E(&B%#?"~<}{9zxww.321rq.',mkkj'&}fddc~}|uz]xwvYWmlTTinmlONihg`eHFFE`_^]V?ZYX;VU7S64PO2M/EDI,*F)'&&;@?"=}549zx6wu3tr0qo-nl*kihh}$#"cb}|{zs\wvYtsrTTinmPkMcbgfeHGba`_^W\?ZYX;VU766KPO2M/EDI,*))>CB%#?87<}{9zxww.32sq/(',mk)jh&ge#db~a_{^\xwvYXsrqpongPNNMhgfedcb[`C^]@>TSX;988MRQ4O1GFK.,HG*E'=!};|z8yw5vt2sq/pn,mk)('hg$#"!~}|uz]xwZutsUUjonQOkdchKIHH]baDB^WV[><XW:U7MLQ42N1/K.,++@EDC&%@?>=<;:92y65432r*/.-,l$k"'&%|#z!b``_ty\wvuXsrqSShmlOMibafIGcbEC_XW\?=YX;V8NMR53O20L/-I,*F)'C&$@#!=~|:98yx/4ussr/(o,+l)('g%$ed!xa__^yxqvYtsrUSihPPejihKJed]bE`_^A\[=Y<:V97SR5P2HGL/-IH+F(>=B%#?>!};438yw5vt2sq/pn,mkjj!&%$ed!~}v_zy\wvuWWlqpSnPfejihKJedcb[`C^]\?=SRW:8T7544INM0.JCBG*(DC&$@98=~|:{y76w4t,+0qo-nl*ki'hfeez!~}`_zyxwvoXVVUponmlkdiLgfeHcbD`_B@\UTY<:VU8S5KJO20L/-I,*F)'C&$@#!=~|:{y765vu210/.-&+l)(i&%$#"ca}vu]]rwvuXWrqponmleNLLKfedcba`_X]@[ZY<WV877LQP3N0FEJ-+G*(D'%A@#>~65:{y7xv43tr0)(-nl*ki'hf$ec!b`|{z]\wvutsrqpinQlkjihJ`edcbDZCX]\[TYRW:UT7RQP22GLK.I+A@EDC&%:#!!~;49z765v32r0/pn,%$)jh&ge#"ca}vuz][wZXtsVqSihmPNjMKgJHdGEDDY^]\?>YRW:UT75KJO20//DIH+F(>=B%#?>!<|438yw5vt2sq/pn,mk)jh&ge#db~}|_^yxqZutWrqpRRglkNLha`eHFEEZ_^A?[TSX;9U86R53O20LKJ-,GFE>C&A@?"=<;{{276wu3,+0qo-,mk)"!&ge#"c~`vuz][wZXtWUqTRnQOkNLhKIeHFba`CB]\[ZS<::9TSRQPIN1LKJ-+A@((=BA@#"=<;:981xvvu210/.-,%*k('&g$#cbbw|{^y[qpuXVrUSoRPlOMiLJfeHcE[Z_B@\[>Y;QPU86RQ4O1GFK.,HGF)(CBA@?>=6;|98y654tt+0/p-m%$)jh&ge#db~a_{^\x[YuXVrqToQgfkNLhKIeHFEEZ_^]@?ZYXWVUTSL5PONML.DIHGF(>'<;@?>=6;|zzy05v321rp(',mk)jh&%fd"yx}`^]]rwvYWslkpSQmPNMMbgfIdF\[`CA]@>Z=;W:8T75QPO21FK.IH+)?>C&$##8=<}:z216wu32s0p(',mk)jh&ge#db~a_{^\x[YuXVrqpSRmfOjiLgfeGG\a`CA]VUZ=;::OTS64PIHM0.J-+G*(D'%A@?"!<;49z765v321qq(-,mk)"!&ge#"ca}vuz][wvYtVlkpSQPPejiLgI_^cFD`CA]@>Z=;W:8T75Q42NML/.IHG@)''&A@?>7<}:98y65u32s0p(',mk)jh&ge#"c~`vuz][wvYWslkpSQmPNjMKgJHdGEDDY^]\?>YXWVOT7RQ4ONM//DIH+F(>=B%#?"~<}{9zx6wu3tr0qo-,m*j"!&ge#db~a_^^sxwvYXsrqpohQOONihgfed]bE`_^A\[=Y<:V97S64P31ML/J,BAF)'C&$@?"=}549zx6wu3tr0/p-m%$)jh&geddy~}|_^yxwvutmrUSSRmlkjihg`IdcbE`_A]@>ZY<:VONS64P31M0.JI,G)?>C&$@#!=~|:{y765vu210/.-,%ljji&%$#"!~}v{^yxwZXnmrUSRRglkNLha`eHFbEC_^A\>TSX;988MRQ42NGFK.,H+)E(&B%#?"~<;:{z76543210).o,+*)(h~%$#"bxav{zyrwpuXsrUponPPeMMbgfeHG\ECCB]V[>YXW:8NMR53O20//DIH+F(>=B%#?"~<}{98y6v.-2sq/.o,l$#(ig%$#dc~w|_zyx[vutsrUSohglOMLLafeHFb[Z_B@\?=YX;9UNMR5322GLK.,HA@E(&B%#?"~<}{9zx6wu321rq.-&m*)jh&%$#"cb}|{ty\wvuXVlkSShmlkNMhgfe^GEED_^]\[TY<WV9TSRQP31MFEJ-+**?DC&A#98=~|:9z7w/.3tr0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpinQOONihgfed]Fa`CAW\[ZY<;VUTSRQJ3110KJIHGFE>C&A@#!76||3876wv3210/.-&+l)('h%$#ccx}|_]yrqvYWsVTpoRmOediLJII^cbE`BXW\?=Y<:99NSR53OHGL/-I,*F)'C&$@#!~~5:98yx543210/.'n+*)('g}$#"!aw`uzyxqvotWrqTonPOOdihKIe^]bEC_B@\?=Y<:V97S64P31M0.J-+GFE('=~;:9yy054u2r*).om+ljii~%$ec!xw|_]\\qvuXVrkjoRPOOdihKfH^]bEC_^A\>TSX;9U86R53O20//DIHG*)D=&$$#>=6;|98y65u32s0p(',mk)jh&ge#db~a_{^\x[YuXVrUSRRglkjMLgf_dGbaD_^]??TYX;9UNMR5322GLK.,HA@E(&BA$?!76;|z8yw5vtss*/.-nm*)(!hffe"!~}v{^yxwZutsUUjonQOkdchKIedGEaZY^A?[Z=X:POT75Q42N1/K.,H+)E(&B%#?"~<;:{z7654-2s0/pn,+*)(ih%$#"!xa__^yxwvutmrUponQOedLLafedGFa`_^]\UZ=XWV9TS5Q42NM0.JCBG*(DC&A#98=~|{{276w4t,+0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpongPkjMhgfHH]baD_AWV[ZY<;VUTSRQPOHM0KJIHG)?DCBA#9"7<;49816w432s0/.nn%*)j'g}|#db~a_{z][wpotWUTTinmPNjcbgJHdGEaDB^A?[><X;988MRQP32G0..-HAF)DC&$:9>!}||387x5u-,1rp.-n+k#"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNMhafIdcFa`_AAV[Z=;WPOT7544INM0.JCBG*(DC&A#98=~|:{y7xvuu,10/po,+$kiih%$#z!b}|{^yxwYYnsrUSohglOMihKIe^]bEC_^A\>TSX;9U86R53O20L/-I,*F)'C&$@?>!~;:927x54us10/.-nm*)('~geed!~}|{ty\wvuXVlkSShmlkNMhgfed]bE`_B]\>ZY<W9ONS64PO2M/EDI,*F)'C&$@#!=~|:{y7xv4us10/po,+*)('~geed!~}|{zyrwZutWUkponmPOjihgfed]bE`_B@VU==RWVU87RQPONMLKD-HGFED&~6}498705.3trrq(-n+*)j'&feez!~a|^tsx[YuXVUUjonQlNdchKIedGbDZY^A?[Z=X:POT75Q42N1/K.,HGF)(=B%@?"=<;{{276wu3,+0qonn%*)jh&}|#db~}`{]srwZXtWUqTRnmPkMcbgfeHGb[DBBA\[TY<WVU86LKP31ML/-IBAF)'CB%#?87<}{zz165vt2+*/pn,mk)jh&ge#db~a_^^sxwvYXsrkpSnmPNdchKIHH]baD_AWV[><XW:U7MLQ42N1/K.,H+)E(&B%#?"~<}{987xw432+r/.o,+*jj!&%fd"yx}`^]]rwvYWslkpSQmPNjMKgJHdcbED_^]\UZ=XWV9TSR44INM0.JCBG*(DC&$@98=~|:9z7w/.3tr0qo-nl*ki'hf$ec!b`|_]yxwZYtsrqpiRPPOjihgfe^cFa`_B@VU==RWVU87RQPONMLE.,,+FEDCBA@?8=~;:{87w5vt2sq/pn,mk)jh&%f#cyx}`^z][wZXtWUqTRnQOkNLhKIeHFEEZ_^]@?ZYXWVUTSLQ4ONMLK-CHGFE'=&;@?>7<5:{8765v32r0/p-m%$)jh&ge#"c~`vuz][wvuXWlUSSRmfkNihKI_^FF[`_^A@[TY<WVU8SR4P31M0.J-+GF)D&<;@#!=<}:z216wu3tr0qo-nl*)(ih%${d!~a|{]\\qvuXVrkjoRPlOMiLJfIGcFD`CA]@>Z=;W:8TSR54ONMFK.IHG*ED&BA$?!76;|z8ywvv-21rp.'&+lj(ig%$e"bxw|_]y\ZvYWsVTpSQmlkNMhgfe^GEED_^]\[TY<WV9TS5QP3N0FEJ-+G*(D'%A$">!};|z8yw5vt2sqpp',+*kj'&%$#z!b}|_zyxZZotsVTpihmPNMMbgfIGc\[`CA]\?Z<RQV97S64P3100EJIH+*EDCBA@9"=<}:98xx/43t1q)(-,+lk('&%$#"y~a|{z][qpuXVUUjonQOkdchKIeHFbEC_B@\?=Y<:V97S64P3100EJIH+*EDCBA@?>7~;:987w/4321q)p',+$)(!&g$#"!b}|^z][wvYWslkpSQmPNjMKgJHdGEaDB^A?>>SXWV98SRQJ3110KJIHAF)DCBA$?>=<;|z8105vt2sqpp',+lj(!~%fdccx}|_z\rqvYWsVTpSQmPNjMKgJHdGEDDY^]\?>YXWVOT7RQPO2ML.JI,G)?>C&$@#!=<}{9216wu3tr0qo-nl*ki'hf$ec!~}`_zyxwvoXsrqpSnmlNNcKK`edcFE`_^]\[ZS<::9TSRQPONMFK.IHGF)'=<A$">!}||387x5u-,1rpoo&+*k(h~}$ec!b`|_]y\ZvYWsVTpSQPPejihKJedcba`_^W\?ZYXWV8NSRQP2H1FKJIBG@E(CBA@#>=};|zyy054us1*).om+lj(ig%fd"ca}`^z][wvuXWlUpoRmlkjiLJf_^FF[`_^A@[TY<WVU8SRQPO20LEDI,*F)'CB%@"87<}{9zx6wu3tr0qo-nl*ki'hf$#"cb}|u^\\[vutmrUpoRmlkMihKJedc\aD_^]@>TS;;PUTS65PONMF/--,GFEDC<A$?>=~;:z8yw5vt21r/o'&+lj('h%e{z!b`|{^\xqpuXVrUSoRPlOMiLJII^cbaDC^]\[ZSX;VU8SRQ33HML/J,BAFED'&A@?>=<5|zzy6543210).o,+*k('g%fd"!b}_uty\ZvuXsUkjoRPlOMiLJfeHcE[Z_B@\?=Y<:V97S6433HMLK.-HGFEDCB;@#>=~|438ywvv-21r/o'&+lj('h%e{z!b`|_]y\ZvYWsVTpSQmPNjMKgfeHGba`_^]\[T=XWVUT6LQPON0F/DIHG@E>C&A@#>=<||387xv4-,1rpoo&+*ki'~}$ec!b`|_]y\ZvutWVkpSnmlOjiKJJ_dcFD`YX]@>Z=;WV97SLKP31M0.J-+G*(D'%A$">!}||3876wv3,sqqp-,%*k('h%$#c!~a`{zsx[vutWUkjRRglkjMLgfe^GEED_^]\UZ=XWV9TS544INM0K-CBG*(D'%A$">=~;{327xv4us10qo-&%*ki'hf$ec!b`|_]yxwZYtsrqjoRmlOjihJJ_dcFaCYX]@>Z=;W:8T75Q42N1/K.,HG*E'=!};|zyy0543ts0/.-,%ljji&%$#"!x}`{zy\wvXtWUqTRnmPkMcbgJHdcFaCYX]@>ZY<W9ONS64P31M0.JI,*F?>CBA$#>=<;:927x54us+*/pnmm$)(i&f|{"ca}|_z\rqvYWsVTpSQmPNjMKgJHdGEaDB^]\?>YXWVUTSL5PO2MLK--BGF)'C<;@#!~~5:9zx6/.3tr0qo-nl*ki'&%fe"!~}|{zyrwZutsrqSinmlkMcLaf_dcb[`C^]@[Z<X;9U86RQ42NGFK.,++@ED'B$:9>!};|z8yw5vt21r/o'&+lj(igff{"!~a`u^yx[YonVVkponQPkjcLJJIdcb[`C^]@[ZY;;PUT75QJINML/.IHG@E(&&%@?>=<5:{87xv.-ss*/.-nm*)('&}$e"!b}|{]]rwvYWslkpSQmPNjiLgI_^cFD`_B]?UTY<:VU86RKJO20LK.I+A@EDC&%@?>=<;4{yyx543210/(-n+*)j'&f$ec!~a|^tsx[YuXVrqToQgfkNLhgJeG]\aDB^A?[><X;988MRQP32MLKJIHG@E(CB%#?>=<;|3z765432+0q.-,m*)i'hf$ecbbw|{^\xqpuXVrqTRngfkNLhgJeG]\aDB^A?[><X;988MRQ42NGFKJI,AF)DCBA$?>=}}4zz1654ut+rppo,%*k('&%f#"baav{z][wpotWUqpSnPfejMKgJHdGEaDB^A?[><X;9U86R5322GLKJ-,G@E(CBA@#>=};:{8x0/4us1rp.-nl*#"'hf$ec!b`|_]y\ZvYWsVTponQPkjcLgfedGba`BBW??TYXW:9TSRQJ3110KJIHG@E(CBA@#!76;|z8ywvv-21r/o'&+ljii~%$e"bxw|_]y\ZvYWsVTpSQmPNjMKJJ_dcbED_^]\[TY<WVUT7RQ3O20//DIH+)E>=B%#?"~<}{9zx6wu3tr0qo-,+lk('&%$#zc~}`^zyxwvYnWrqponmfkNihgJedcEEZ_^A\>TSX;9UT7R4JIN1/KJ-H*@?D'%A@#>~65:{y76w4t,+0qonn%*)j'g}|ddy~}|_ty\wvutWrqpRRgOOdihgJI^GEED_X]@[ZYX;VU766KPO20LEDI,*FE(C%;:?"~<}{9zx6wu3tr0qo-nl*ki'hfeez!~}`_zsx[vutsVqpRnmPkMcbgJHdGEa`CA]VUZ=;W:8T75Q42N1/K.,H+)EDC&%@?8!<;:9z765uu,rr).-,ml)('&}fddc~}|{zsx[vutsVTjinQOkNLKK`edGbDZY^A?>>SXW:U7MLQ42N1/K.,H+)E(&B%#?"~}}4987xw43210).o,+*)j'&f$ecbbw|{^\xqpuXVrUSoRPlOMiLJfIGcFD`_^A@[ZYXWVO8SR53ONMLK.C,GFEDCB;@#>=<}:9y7xv43t1q)(-nlkk"'&ge#zy~a_{^\xwZXtmlqTRnQOkNLhKIeHFbEC_^]@UZ=XWVU8SRQ33H00EJIH+*?(&&%@9>!<;:9z76vuu,10qo-&%*ki'&g$dzy~a_{^\x[YuXVrUSoRPlOMiLJfIGFF[`_^A@[TY<WVUT7RQ3ON1L.DCH+)E(&BA$">76;|z8yw5vt2sq/pn,mk)jh&%$ed!~w`{zyx[vutVVkSShmlkNMhgfe^GEED_^]\[TY<WVUT75KJO20L/-,,AFE(C%;:?"~}}498y6v.-2sq/pn,mk)jh&ge#db~a_^^sxwvYXsrqpohmPkjihKfeGcFDCCX]\?=YRQV97S64P31M0.J-+G*(D'%A@?"!<;:9870w43tr0/.-,m$k('&%$#z!b}|{^yxZYYnsrUSohglOMLLafeHcE[Z_B@\?=Y<:V97S64P31M0.J-+GF)D&<;@#!~~5:98y05v3210q.-,ll#ii~%$#dcxa__^yrwZutsrUpoQPPejiLJf_^cFD`_B]?UTY<:V97S64P31M0.J-+G*(D'%A$"!!6;:9zy6/4u210/p-,l*)j'g}|#db~a_{z][wpotWUqTRnQOkNLhKIeHFbEC_^]@?ZYR;VU86RQPON1F/JIHGFE>C&$@#>7<;:9z16w4321r/.n,+l)i!~%fd"ca``uzy\wYonsVTpSQmPNjMKgJHdGEaDBAAV[ZY<;P977LQ4221FK.IHGFE(CBA##8~~5:98yx/4u210qo-,+*)j!h%$#"!~w|_zyx[YonsVTpSQmPNMMbgfIdF\[`CA]@>Z=;W:8TS6Q3IHMLK.C,GFEDCB%^#K=[}GziUUfSt,ON)ooK%kH5XgCBdSRQ=v_^9'[%Y#FlUTR.-P>j<htIHH]o4`l1A?>Zwv*:8TSq5]3!kk/DgHTwd'b%;^L\[Z|49i1Tv4u2rr)(nKl76jE~%BdSbQ`Ouz\[8ZuWs3UC0Rm->jvKt`HG#EE`B1@/z==vutOT&Ro]O[MYKJVyf*c(b%%ML]=Z;X3i1xTRRt+*pp-,%[jYhD%CAARa}+_MLr&Y$5V3DToAmPej*;a`e$]#[Z_B{@[-fwv)UT&qKPmllj/hhBx)(>C&_M^]7Z}Xz8yTf.@Qba/;^,lkk"!WC1BS@-`_uMyK7I5XVV200{mfNj*uK&HHpb[D}B@zy=,+QV9Tr6p]"Nk0|{VBeSRcPa$_9Kn};{zEhgT4u,>*);'nJIkiEW210SRQ=<*;(K&I$tslk}BA@?eMv;(JI$F""mB^|i>>=vW)9'7%$#2NlYX-,HA@)''%%_?8[~;{zzVCT.d,s*N_n,mk6"FDCCTA?>P+{z(xq655s22}S/gfkjLL:fIH#EE!YAjVzgYX:)(s65p]m[MY/hCB+)RcPa$#""=<|43ixwS4Q2P*`p'KJHZ(!WVBec!-P=*ML9J6$GF3q10A-O>=c;(J%HGF!~_^0?.-w+QcUs`p4JmH1//{gyxeRQ

Try it online!
If the challenge didn't require halting at some point (eg. eof), it becomes pretty trivial, scoring 2334 bytes:
bP&A@?>=<;:9876543210/.-,+*)('&%$T"!~}|;]yxwvutslUSRQ.yx+i)J9edFb4`_^]\yxwRQ)(TSRQ]m!G0KJIyxFvDa%_@?"=<5:98765.-2+*/.-,+*)('&%$#"!~}|utyrqvutsrqjonmPkjihgfedc\DDYAA\>>Y;;V886L5322G//D,,G))>&&A##!7~5:{y7xvuu,10/.-,+*)('&%$#"yb}|{zyxwvutmVqSohmOOjihafeHcEa`YAA\[ZYRW:U7SLKP3NMLK-I,GFED&%%@?>=6;|9y70/4u210/o-n+k)"!gg$#"!x}`{zyxZvYtsrqSoRmlkjLhKfedcEaD_^]\>Z=XWVU7S6QPON0LKDI,GFEDCBA#?"=};438y6543s1r/o-&%*k('&%e#d!~}|^z]xwvuWsVqponPlOjihgIeHcba`B^A\[ZY;W:UTSR4PI2MLKJ,,AFE(&B;:?"~<}{zz165v3s+*/pn,mk)jh&ge#db~a_{^\xwvoXsrqpRnmfkjMKg`_GG\aDB^A?[><X;9U86R53ONM0KJC,+FEDC&A@?!!6||3876w4-tr*/.-&+*)('&%$e"!~}|utyxwvutWlkponmlOjchg`edGba`_XW\?ZYRQVOT7RQPINML/JIHAFEDC&A@?>!<;{98yw5.-ss*/pn,+lj(!~ff{"ca}`^z][wZXtWUqTRnQOkNLhgfIdcFaZ_^A\[Z<XW:U8SRQPOHML/JIHG*ED=%%:?>=~;:{876w43210/(-,+*)('h%$d"ca}|_z\rqYYnsVTpoRPledLLafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(DCB%@?"=<;|98765.3210p.-n+$)i'h%${"!~}|{zyxwvuXVlkpSQmlOjLbafIGcbE`BXW??TY<:V97S64P31M0.J-+G*(D'%A@?"=<}:98y6543,1r/.o,+*)j'&%eez!~a|^tsx[YutWUqjinQOkjMhJ`_dGEaDB^A?[><X;9U86R53O20LKJ-HG*ED'BA@?>7~;:{y7x5.3210q.-n+*)jh&%$#"c~}`{z]rwvutWrkpohmPkjihafI^cba`_^A\[>YXW:UTS5QP3NM0KJ-HGF?D'BA:?>=~;:z8765v32s0/.-nl$#(ig%fd"ca}|_]yrqvYWsVTpSQmPNjMKgJHdGEa`_B]\?ZY<WVUTMR5PO20LK.IHA))>CB%#?87}}49zx6wu3tr0qo-nl*ki'hf$ec!~}`{^yxwvotsrUponQlkMihKIe^]EEZ_B@\?=Y<:V97S64P31M0.J-+GFE(C&A@?8=<;:{876w43s10qo-&%kk"'hf$ec!b`|_]y\ZvYWsVTpSQmlkNiLgf_dcba`C^]\?ZY;WV97SLK33HM0.J-+G*(D'%A$">!};|z8yw543t1r/(-,+*)(i&%fd"!~}|_t]xwvutslqTonmPkjLhKIeHFbEC_^A?[TSX;9UT7R4JIN1/K.,H+)E(&B%#?"~<}{987x/4u21rp(',mk)jh&%fd"yx}`^z][wZXtWUTTinmPkMcbgJHGG\a`C^@VUZ=;::OTS6Q3IHMLK.-B+FE(CBA##8~~5:98yx5.3t10q.-,+*ki'~}eez!~}`_zyxqvYtsVqpoQQfkjMhJ`_dGEaDBAAV[Z=;WPOT7544INM0K-CBG*(D'%A$">!};|z8yw5vt210qp-,+*#j'&g$#"!~a_{ts[[putsVUponmlkdMhgJedcEEZ_^A\>TSXWV98SRQPONMFK.IHGFE'=BA@?!7~5:9816/4u21r/.-,+lj(!~ff{"!~a`uz]xwvYtsUqTRnQONNchgJHd]\aDBAAV[Z=;WPOT7544INM0.JCBG*(''==RWV97SLKP31M0.J-+G*(D'%A$">!}||3876wv-t10/p-,l*)(i~%fddcx}`{zy\wvXtWUqTRnQOkjMhJ`_dGEDDY^]@[=SRW:877LQP3N0FEJ-+**?DC&A#98=~|{{276w4t,+0qonn%*)j'g}|#db~a_^^sxwvYXmrUponQlkMiLJfIGFF[`_B@\UTY<:99NSR53OHGL/-,,AFE(&B;:?"~}}498yw5.-2sq/.-n%l)('&%$e@b>,+^^:87Z5n"!10/QP-kMv(gf%Gc543}|0{[-YXu)t87L5]Ol~jjiz++evbaa`M^!=Z|kWWD05S3?O*)o'JJH)F!~f1TAy>,<^]:xJ6YXmlD0SAQPk+vKaJ%%F5ECCX|zz=xRQ

Try it online!
Explanation
I've been asked to explain how the program works. I'll pick on the second one as it's way easier to explain it than the first one, but the way both of these work is really similar.
Let's start things off with decrypting the code. As someone down in the comments did it before I started working on the explanation, so I really advise you to check it out.
It doesn't make reading the program any easier one would say, but before we jump straight into the code, let's review basics of Malbolge.
The virtual machine is based on trits (trinary digits). Each machine word is ten trits wide, making it range from 0 to 2222222222t (= 59048d). Each memory position holds a machine word; the addresses are one machine word wide too. Both data and code share the same memory space.
There are three registers, each of which holds one machine word, initially 0: the code register C which is a pointer to the instruction that is about to be executed, the data register D used for data manipulation and the accumulator A also used by several instructions to manipulate data.
If the instruction to execute is not in the range 33-126, execution stops (the reference interpreter hangs in this case due to a bug). Otherwise, in order to determine the actual instruction to execute, the value pointed to by the C register is added to the C register itself and the result divided by 94, taking the remainder.
Here is a table of all possible instructions.

(C+[C])%94
Description
Pseudocode
Op

4
Set code pointer to the value pointed to by the current data pointer.
C = [D]
i

5
Output the character in A, modulo 256, to standard output.
PRINT(A%256)
<

23
Input a character from standard input and store it in A.
A = INPUT
/

39
Tritwise rotate right.
A = [D] = ROTATE_RIGHT([D])
*

40
Set data pointer to the value pointed to by the current data pointer.
D = [D]
j

62
Tritwise "crazy" opertaion (see table below).
A = [D] = CRAZY_OP(A, [D])
p

68
No operation.
NOP
o

81
Stop execution of the current program.
STOP
v

An image of the table can be found here
Now as the code is more understandable and it's actually possible to tell what is happening there, we can jump to the general idea of what is happening there.
Without any jumps, programming Malbolge is pretty much trivial. When the jumps are used though, there is decrypting task needed to be done before executing this code again. Everytime an instruction is executed, it's getting straight after encrypted, so it doesn't behave this way it did before.
To illustrate the workaround, let's look at normalized Malbolge cat program:
jpoo*pjoooop*ojoopoo*ojoooooppjoivvv
o/i<iviv
i<vvvvvvvvvvvvv
oji

So as you can see, on the second line we have / and < instructions dealing with I/O stuff. Utilizing the fact that C register is the instruction pointer, we can modify it using i instruction effectively creating a branch. Before the branch happens though, we need to decrypt instructions that just a few cycles away read and wrote output to and from TTY, combined with a jump. As there is no real way to store constants effectively, we need to embed many non-related instructions and use their value to compute other constants needed (utilizing the fact that Malbolge doesn't separate program and data)
Note: Parts of this answer were taken from Esolang wiki Malbolge page licensed under CC0 - link.
Possibly, you might want to check my other answer featuring Seed

Woah! How did you make this? How do you program in Malbolge? (these are serious questions, by the way)

The day that someone writes, in Malbolge, a program that simply copies its input to it's output, is the day my hair spontaneously turns green. It's the day that elephants are purple and camels fly, and a cow can fit through a needle's eye. This seems to surpass that.

@Adám, by a factor of 2, at least.

First time hearing of Malbolge, but reading those docs all I can think of is: dang, this is an impressive answer. Is it possible to explain your code, or is it beyond explaining? ;)

Seriously, I've always been interested in programming in Malbolge, but I'm always confused by the docs

+1 for "it becomes pretty trivial"

Here's what the shorter code looks like when decrypted and before running it. Malbolge commands are j, i, *, p, <, /, v, o.

The fact that this was done in a few hours... let alone, done at all. Phew. I read your paper on the turing completeness of seed, might you have written a Malbolge transpiler?

How did you decrypt the code after jumping back with the i instruction (I can see a lot of p, *, and j, but how does it play into the program)? Also, why are there multiple halt, input, and output instructions?

@MilkyWay90 there are multiple halt, input and output instructions, because malbolge is storing data in the same memory where it stores code. Does it hint anything to you :)?

Are those the backup I/O and halting instructions in case one of them gets modified?

Partially yes, partially no. There needs to be zero halting instruction, as this program doesn't halt. These "instructions" are serving different purpose. You might want to check this wiki page to clarify state of art a bit. Or try to analyze the code yourself (the recommended way - you will learn a lot, and the process will be really enjoyable)

brainfuck, 6 bytes
,[..,]

Try it online!
For once, a really competitive answer in brainfuck. :-) It just reads from the standard input (,), then loops while the character read is not zero ([), writing the character read twice (..) and finally reading a new character (,) before going back to the start of the loop (]).
Alternative 6-byte answer:
+[,..]

Try it online!

It had to happen sometime.

given brainfuck's 8 instructions, could be argued as 2.25 bytes?

i don't understand bf much, why exactly could it be argued so?

@mTvare you only need 3 bits to codify 8 different instructions. Hence 3 bits times 6 instructions my code has equals 18 bits, 2.25 bytes.

Seed, 6013 3942 3884 3865 3848 bytes
6 2686150228553910251590139707025615036563204497823963635717768129239771871066022173506550480510882628259267028226290577985584582829987099606110915656117177113555095646841841520224800333754793732176561479800611856258812006670385981709167679328497862503284773114717364645850756926464567857029605682209030697372493435852024478962025612141035167904456425050991742516020282696732660004824569723936406080643638019715421991278634074220365586727498681650073989748857985341022350116695714407041551609933358182688736747622670056818175549484918971558384479903673900409406866275258032866680967195428439907751537922194839977711106739550525066186108781580088916582559490041917035011328862266125578018990106393872489460844458091217404944194309597162769266585917996079831048944050703695352212652362891425728346891039020051565145149143668695374506752075410956647268061596926723805877631732070244839345640289062870487268706837056753112890753688530410829624567367052492603150395779619674714389456447573342335882718419424356991739625084740814435581409670174841935167450868967735568432921607395284483532735870628809137816139721467391760314297120583388009684979379888771619327969950939260709632318979448755571394507744993723267176377451465261335636767345281382139780890626858048062851714445255458413414708836044457819560626602471881203745677166851290194466534044374122781840150694963232713079984019097616802988558052961445185981197848860688635007868494303883280609553158126926303057368716954797175868772233997584782178460308584468311133667562020523260687787209651365697360075036255149184531675013585317549831215044187699501112214237282761452176427542227751840469500783022037518267131004723958694850409020207947539046371030202918430731468837057173037358435898981729128093138565524861044307737736772778645659866179416374742499528142506977571896833797572787168504674372995624869224644028121889021513694674680344413147327217671463636201883832593707987630471763158950694907193475270346642656464131212900528377257996057522592531063490286796434946290829640562975054259249630102041301990094261151488784971084438450904697283402436878185751193256803412549504172175692725366543545573099651580644132336272302990268431569623087644930350666119986012078396755208814027614451748455718916151950218835893255721018309717807161101069849247670957963270760531996609510342178009605381013854568528344071028665101709824510991652144229895556116304356971449229862349660751509158124118556805449346752918775201366378708970673708268140336609704879631200464020207189960217784283188350457711700181561855735903701439931161728546207607766764248018356183768557244013532032616392458312600465372655052565572757979232509950076857757257164261786986456779565081319671440867797151240096925123970490604003172676471092543424462070540303172987644037832692737644573481399927217285232015082118420498058022229538934735831710860610342762500071914715742707928060606416262583307855509796730058097681208691054336064995992598081644175617375019325706441005506100489323794725547244923204524790583484243672718647866979116309868261348266944902049457094368284266044502218232850494065571536043568039093446786891928597439310947971461490128765873399872574753055564655381318395939745692438909430171644009177696549501234738931977436030245682360974103741227416811200635596942701451202333113537361407624672328798572271366897755165037017879673502748767425083758652376018772700583221474572236166246539494675416322678094399996691972837962509574037110004298629947088012862552029152119412750923308070223808629424081676003170951500587426197322368913565250353332410276730344732325753114510178069340400741671217608323179698501977213623893949006870978691284571486316780769512681865771113879654002525802085758553029765815927252866913455193686303619992165147682671351400793392238437682055370542229871989802092530537034276944154276536658348210

Try it online!

I've reached my daily vote limit, but I'll upvote this in 2 hours

I can't begin to understand this

This has actually really surprised me, as this answer may be wayyy more impressive than the Malbolge one

Any chance you can explain how you got this one? Will such a description include the word 'trivial' at any point?

@ouflak well, this time, it won't include the word 'trivial', because the challenge required reversing the Mersenne Twister

How did you reverse the Mersenne Twister?

Soon I expect you'll post a thread on golfing tips for Seed.

Maybe someone's interested, an in-depth description of one of my algorithms for Seed cracking and example impl in assembly, together with some background and misc info: http://kspalaiologos.now.im/?id=9

An edited version (fixes a bug) is on github: https://github.com/kspalaiologos/writings/blob/main/p1.md

3846 bytes generated with bx5 (TIO link too long) https://privatebin.net/?35a56985b7f6b1ff#BEMbCS6YZTZduexWEohCkGCQbqEkKsybxb6hw4S2ZA1H

Jelly, 1 byte
Full program.
ż

Try it online!

Oh, I was too slow. Was just about to post Ḥ

FWIW I'd note that this is a full program since as a monadic Link it accepts a list of characters but returns a list of lists of characters - so it accepts a Python string as an argument and prints the result (as does my 1 byter, although this one may be augmented to work as a Link (ż\F`), while mine cannot I believe)

(Nick Kennedy points out mine can become a Link with uneval, eval :))

@JonathanAllan Pfffft, uneval-eval :)))

This looks to me like 2 bytes character ... $ echo -n "ż" | hexdump -C
00000000  c5 bc                                             |..|

@Jakuje Jelly has its own codepage, so each of the 256 characters it contains is encoded as 1 byte.

Shakespeare Programming Language, 139 129 109 106 bytes
-3 bytes thanks to Jo King
N.Ajax,.Page,.Act I:.Scene I:.[Exeunt][Enter Ajax and Page]Ajax:Open mind.Speak thy.Speak thy.Let usAct I.

Try it online!
Spews warnings and terminates with an error. Deal with it.

@Jo King woah, this is a really clever use of [Exeunt]!

Haskell, 15 14 13 bytes
(>>=(<$"dd"))

Try it online!
or legibly:
\xs -> concatMap (\x -> map (const x) ['d','d']) xs

Explanation: Lists are a Monad in Haskell, and using the bind operator >>= is a concatMap, executing a function that takes an element and returns a list on each element of the list and then concatenating the resulting lists into one big list.
Now we just have to build a function that, given a value, returns a list of that value twice, which is accomplished by (<$"dd"), which can be read as "Take the list ['d','d'] and replace every element with the argument of this function. The "dd" could be any expression that results in a list of exactly two elements, but this is the shortest I could come up with.

using <$ was something I never would've thought of

@MegaMan Credit goes to Laikoni, who gave me that hint in another codegolf challenge a year ago https://codegolf.stackexchange.com/questions/6281/draw-a-sierpinski-triangle/165554#165554

Pyramid Scheme, 229 218 213 bytes
    ^
   /l\
  /oop\
 ^-----^
 -^   ^-
 /[\ /]\
^---^---^
-^ / \  -^
^-/out\ / \
-^-----/set\
 -^   ^-----^
  -^  -    /+\
  / \     ^---^
 /arg\   /1\  -
^-----^  ---
-^    -
 -^
 / \
/arg\
-----^
    /1\
    ---

Try it online!
This can definitely be shorter. Input is taken via command line arguments. This equates to basically:
str = input()
n = 0
while str[n]:
  print(str[n]*2)
  n += 1

With a few caveats, like the printing actually being handled in both the loop condition and the loop body.
Alternative 215 byter:
     ^
    /l\
   /oop\
  ^-----^
 /[\    -^
^---^   / \
-^ ^-^ /set\
^- -^-^-----^
-^ / \-    /+\
^-/out\   ^---^
-^-----  /1\  -
 -^      ---
  -^
  / \
 /arg\
^-----^
-^    -
 -^
 / \
/arg\
-----^
    /1\
    ---

Try it online!

The set can be shifted up and left without interfering with anything. Try it online!

Pyramid Cult came to PPCG!

05AB1E, 2 bytes
ø˜ or øS  (both 05AB1E versions)
ζ˜ or ζS  (new 05AB1E version only)
€D or €Â  (new 05AB1E version only)
.ι        (new 05AB1E version only)
ºS        (new 05AB1E version only)
·S or xS  (legacy 05AB1E version only)
+S        (legacy 05AB1E version only)

Ok, I give up. I'm unable to find a 1-byter to solve this. Loads of 2-byters, though..
Try ø˜ online or Try øS online.
Try ζ˜ online or Try ζS online.
Try €D online or
Try €Â online.
Try .ι online.
Try ºS online.
Try ·S online or Try xS online.
Try +S online.
I/O as a list of characters.
Explanation:
ø    # Zip/transpose the (implicit) input-list with itself
     #  i.e. ["a","b","c"] → [["a","a"],["b","b"],["c","c"]]
 ˜   # Deep flatten it
     # OR
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

The only program which works the same in both versions of 05AB1E. :)
ζ    # Zip/transpose the (implicit) input-list with the (implicit) input-list
     #  i.e. ["a","b","c"] → [["a","a"],["b","b"],["c","c"]]
 ˜   # Deep flatten it
     # OR
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

This version basically works the same as the one above for the new version. In the old version you would need an explicit pair ‚ first, and then you could zip/transpose that. Just ζ on a 1D list will be a no-op in the legacy version of 05AB1E.
€    # For each character in the (implicit) input-list,
     # keeping all values on the stack into the resulting list:
 D   # Duplicate it
     # OR
 Â   # Bifurcate it (short for duplicate & reverse copy)
     # (which will be output implicitly as result)

In the new version of 05AB1E, it keeps all values on the stack into the resulting list when doing a map. Whereas with the legacy version of 05AB1E it would only keep the top value. Which is why these only work in the new version.
.ι   # Interleave the (implicit) input-list with the (implicit) input-list
     # (which will be output implicitly as result)

This builtin wasn't there yet in the legacy version of 05AB1E.
º    # Mirror each value in the (implicit) input-list
     #  i.e. ["a","b","c"] → ["aa","bb","cc"]
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

In the legacy version of 05AB1E, the horizontal mirror builtin would be ∞ instead of º. However, ∞S doesn't work in the legacy version, because it would implicitly convert the list to a newline-delimited string before mirroring it completely (Try it here), after which the S would also include these newlines.
·    # Double each character
     # OR
x    # Double each character (without popping)
     #  i.e. ["a","b","c"] → ["aa","bb","cc"]
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

Double is short for 2*. In the new version of 05AB1E, build in Elixir, this only works on numeric values. The legacy version of 05AB1E was built in Python however, so 2* works similar and repeats the character.
+    # Append all characters in the (implicit) input-list at the same indices
     # with the characters of the (implicit) input-list
     #  i.e. ["a","b","c"] → ["aa","bb","cc"]
 S   # Convert it to a flattened list of characters
     # (which will be output implicitly as result)

Again, because the legacy version of 05AB1E was built in Python, "a"+"a" results in "aa", whereas the + cannot be used to append strings in the new version. (PS: There is an append for strings which works in both version, which is «, but when giving two list arguments it will concatenate them together instead of merging each string at the same indices like the program above (Try it here).)

There's also ζ˜ for modern 05AB1E.

@Grimy Didn't realize that doesn't work in the legacy version. I thought it was the same as ø˜, so I didn't bother adding it as well. I have added it (as well as øS/ζS/xS).

Alternatively, øJ, ζJ, ºJ, ·J, xJ, or +J.

Python, 34 25 bytes
lambda i:sum(zip(i,i),())

Try it online!
Another one that returns a string instead of a list of characters:
for i in input():print(i,end=i)

for i in input():               asking for the input, and doing a
                                for loop for every char in the string.
                 print(i,end=i) print the character, and then close
                                the line with the same character.

Try it online!

lambda i:sum(zip(i,i),()) should do for -9.

@Mr.Xcoder this returns a list of characters, rather than a string. The original can be improved by 3 bytes, though: for i in input():print(i,end=i)

lambda i:''.join(c*2 for c in i) 32 bytes but returns a string and not a list

Still works with 31 bytes :) lambda i:''.join(c*2for c in i)

x86-16 machine code, IBM PC DOS, 16 10 8 bytes
Assembled byte xxd dump
00000000: b401 cd21 cd29 ebf8                 ...!....

Unassembled listing:
B4 01       MOV  AH, 01H        ; DOS read char from STDIN (AH=01)
CD 21       INT  21H            ; read char into AL (echoes input)
CD 29       INT  29H            ; write char in AL to console again
EB F8       JMP  -8             ; continue looping until break

Standalone PC DOS executable.  Input from STDIN, output to console.
Interactive console input:

Input by pipe:

Original 16 byte answer:
Assembled byte xxd dump
00000000: d1ee ad8a c849 acb4 0ecd 10cd 10e2 f7c3  .....I..........

Unassembled listing:
D1 EE       SHR  SI, 1          ; point SI to DOS PSP (080H)
AD          LODSW               ; load input length into AL
48          DEC  AX             ; remove leading space from length counter
8A C8       MOV  CL, AL         ; move length to loop counter
        C_LOOP:
AC          LODSB               ; load next char into AL
B4 0E       MOV  AH, 0EH        ; PC BIOS tty output function
CD 10       INT  10H            ; write char to console
CD 10       INT  10H            ; write char to console again
E2 F7       LOOP C_LOOP         ; continue looping through chars
C3          RET                 ; exit to DOS

Standalone PC DOS executable.  Input via command line, output to console.

Use XCHG AX, CX instead of MOV CL, AL to save a byte.

@NieDzejkob, thanks! The only issue there is that LODSW is going to put the leading space (20H) from 81H into AH which will of course mess up the LOOP if that's in CH... Bummer.

Jelly, 1 byte
ż

Try it online!
Pardon my inexperience, I'm just getting started with Jelly. What I believe is happening is that we've defined a dyadic chain, which treats a single argument as both the left and right arguments. In this case, the chain consists of "zip; interleave x and y", interleaving the input string with itself.
Someone already posted a 1-byte Jelly solution, so I hope it's not bad manners to post mine.

Welcome to the site!  It perfectly fine to post an answer that ties an existing one especially if your answer has an explanation and the other does not.

Jelly, 1 byte
Ḥ

A full program printing the result.
Try it online!
How?
Uses a bug feature...
Jelly's "double" atom, Ḥ is implemented with Python's * and it vectorises, while Jelly's lists of characters (its only "strings") are implemented as lists of Python strings which are usually just one character long - that is until we realise that in Python 'blah'*2='blahblah'...
Ḥ - Main link: list of characters (as parsed from an argument as a Python string)
  -                       e.g. ['A','b','b','a']
Ḥ - double (vectorises)        ['AA','bb','bb','aa']
  - implicit, smashing print     AAbbbbaa

If you wanted to make a monadic link (rather than full program), you could use ḤṾV

Ah, I had no idea that'd work - nice!

Looks to me like three-bytes character: $ echo -n "Ḥ" | hexdump -C00000000  e1 b8 a4                                          |...|

@Jakuje  The code is one byte, af, Ḥ is just a visual representation of that byte, see Jelly's code-page (also linked in the header of the post).

sed, 10 8 bytes
s/./&&/g

Try it online!
Thanks to @manatwork for -2 bytes.

Those lengthy escaping… Better s/./&&/g.

This replaces each/any character with the whole matched search pattern (&), in this case one character, twice via &&.

JavaScript (Node.js), 22 bytes
Takes input as an array of characters.
s=>s.flatMap(c=>[c,c])

Try it online!

JavaScript (ES6), 26 bytes
Takes input as a string.
s=>s.replace(/./gs,c=>c+c)

Try it online!
Alternate version suggested by @PabloLozano:
s=>s.replace(/./gs,'$&$&')

Try it online!
Doing it the recursive way is also just as long:
f=([c,...s])=>c?c+c+f(s):s

Try it online!

s=>s.replace(/./gs,c=>c+c) so that . also matches newlines

@NahuelFouilleul Good catch. Thanks!

Would s=>s.map(c=>c+c) not work?

@Oliver Won't that result in something like ['a','b','c'] -> ['aa','bb','cc'] instead of the intended ['a','a','b','b','c','c'], though?

@KevinCruijssen The join('') should take care of that. On second thought, that may be augmenting the output in a non-standard way so that may not be valid.

@Oliver I don't think it's valid. My 05AB1E would have a few 1 byte solutions in that case. Default I/O for a string is either, well.. a string, or a list/array/stream of characters / single-char strings. ["aa","bb","cc"] is a list of strings however, neither a string nor list of characters of itself. Adding a join or flatten it to a list of characters is valid, but would have to be counted towards the byte-count.

@KevinCruijssen Yeah, I agree :-)

Another option with replace and 26 characters: s=>s.replace(/./gs,'$&$&')

@PabloLozano Added. :-)

PowerShell, 29 23 21 bytes
-6 bytes thanks to Andrei Odegov
-2 bytes thanks to mazzy
-join($args|%{$_+$_})

Try it online!
Takes input via splatting, essentially making it an array of chars

-6 bytes.

what do you think about splatting? Try it online!

Haskell, 8 bytes
(<*"x2")

Try it online!
Any two-character string works in place of "x2".

Might you be interested in tackling https://github.com/haskell/containers/issues/314 ?

APL (dzaima/APL), 2 bytesSBCS
Anonymous tacit prefix function.
2⌿

Try it online!
⌿ is "replicate" :-)

Rust, 83 46 45 bytes
|x:&str|for c in x.chars(){print!("{}{0}",c)}

Try it online!
I don't like this, but it's not cheating.

-1 byte thanks to Maya.

-1 byte with print!("{}{0}",c)

44 bytes

@mousetail Nice. Forgot they'd added that feature. (Only works on recent versions of Rust, though.)

C (gcc), 40 bytes
f(s,t)char*s,*t;{while(*t++=*t++=*s++);}

Try it online!
Assumes t is a buffer which is large enough to store the output.
Probably not standard-conforming, but it works on TIO.

32 bytes - https://tio.run/##S9ZNzknMS///P01Dq1hHq0SzujwjMydVQ6tEW9sWQhRra2ta1/7PzCtRyE3MzNPQVKjm4gTxSqJNDWKtuTjTNHyUXPJLk3JSFYoLUhOzlXRKNIHCBUVARWkaSqo5xUo6CiCh2v8A

Brachylog, 2 bytes
jᵐ

Try it online!
Explanation
 ᵐ     Map on each char
j      Juxtapose the char to itself

Pyth, 2 bytes
.i

Try it online!
.interleaves two copies of the input together. The input is implicit, so a 'full' version of this program would be .iQQ, where Q is the program's input.

Perl 5 (-0777p -Mre=/s), 10 bytes
s/./$&$&/g

TIO

Befunge-98 (PyFunge), 6 bytes
#@~:,,

Try it online!

Java 8, 27 bytes
s->s.replaceAll(".","$0$0")

Try it online.
Old 31 bytes answer before the rules got changed:
s->s.replaceAll("(?s).","$0$0")

NOTE: The suggestion of @EmbodimentOfIgnorance (\n|. instead of (?s). has been reverted, since it fails if the input contains \r. Thanks for reporting to @OlivierGrégoire.
Try it online.
Explanation:
s->                             // Method with String as both parameter and return-type
  s.replaceAll("(?s).","$0$0")  //  Regex-replace all matches with the replacement
                                //  And return the changed String as result

Regex explanation:
(?s).                           // Match:
(?s)                            //  Enable DOTALL mode so newlines and carriage returns
                                //  are treated as literal
    .                           //  A single character

$0$0                            // Replacement:
$0                              //  All character(s) found in the match
  $0                            //  And again all character(s) found in the match

(?s). can be replaced with \n|.

The \n|. version doesn't work correctly with input "\r". The (?s). version works correctly with \r, though.

The requirement now says ASCI in range 32-126, so you can golf to 30 with @EmbodimentofIgnorance's shortcut.

@OlivierGrégoire well if the range is 32-126 you can golf to 27 with just .

@OlivierGrégoire Yeah, I saw the comments below the challenge and was waiting for the edit. And Grimy is indeed right that we can drop the \n| completely. I personally liked the older rules slightly more, but whatever.

Oops, sometimes I forget that \n is printable but not part of the ASCII printable range.

@OlivierGrégoire I know the feeling. ;) Same with tabs (and maybe carriage returns). Always thought the term 'printable' didn't really make sense for just the $[32,127]$ codepoint range, but whatever.

Haskell, 15 bytes
Here (:)<*>pure takes an argument and returns a list containing this argument twice. Then >>= maps this function over every entry of a the input list (which is a string in our case) and flattens the result (a list of lists) back to a list.
(>>=(:)<*>pure)

Try it online!

Had the same first answer, love the use of the S combinator

@cole I only saw your shorter answer when I was about to submit this one - but I posted it anyway as I thought it was so elegant:)

J, 6 3 bytes
-3 bytes thanks to Richard Donovan
2#]

Try it online!
K (oK), 8 4 bytes
-4 bytes thanks to ngn!
{2}#

Try it online!

Galen isn’t it just 2# for two bytes, as in...

2# ‘qwerty’ ===> ‘qqwweerrttyy’

@Richard Donovan yes. It works!

similarly in k: {2}#

@ngn Hmm, I didn't know, apparently! Thank you!

dotcomma, 15 14 bytes
[[],][.[[,],]]  code
[[],]           push 0 to the queue
     [.      ]  while next block is non-zero
       [[,],]   pop from the queue and push it twice

Nice golf, I was sure something could be shortened there but I couldn't find it :p

Thanks! I don't think there's anything left to change, but I might be wrong.

makina, 96 bytes
v   L>C
v>n0; >n0;
>wv ^
>Ov ^
^i>?g
^IvOC
^ nv
;1<>ppuv
^<<<OOO<
^   >vv
;0nCUv>n1;
   T<<
;1nC

It's hard to explain makina code, but basically this goes through each letter of the input and prints it twice.

interesting language. is there any documentation for it?

@Razetime There is now! https://esolangs.org/wiki/Makina

JavaScript, 39 bytes

alert([...prompt()].map(a=>a+a).join``)

May not be the shortest but at least original.
EDIT
Removed 2 bytes thanks to @emanresu A

red sus. (nice answer tho)

You can do .join\``

GolfScript, 7 6 4 bytes
{.}%

[Try it online!][TIO-jyx60w31]
my first golfscript program! Other people's explanations on here were super helpful for me to refer to so I'll type mine out even though its pretty short
{ }        code block
 .         copy the top item of the stack
   %       array map

Try it online!

doesn't this beat other golfscript answers? nicely done

MarioLANG, 23 20 17 bytes
>,
"+
.[
.<
!-
#=

Try it online!
Unlike brainfuck, MarioLANG returns -1 on EOF, so we must increment the value read before comparing it to zero, and then decrement before printing it. This is probably the shortest answer possible in MarioLANG.

Scala, 37 bytes
def^(s:String)=s.flatMap(x=>Seq(x,x))

Try it online!

Wow, a nice one with clever use of Seq ; I was about to make one with replace but this one is like 10b shorter

According to other code golf solutions in Java, Kotlin and C#, it seems to be accepted to provide just a Lambda without binding it to a name. Thus, like Kotlin's it one can make use of Scala's _, for example, _.flatMap(x=>Seq(x,x)), using only 22 chars. TIO. Of course, this is just a counting trick, which does still follow your nice approach.

@cubic lettuce, I think those answers do not fully comply with the rules. Some time ago I got this useful recommendation https://codegolf.stackexchange.com/questions/174521/the-written-digits-sequence/174645#comment420978_174645. I would not bother with such "counting tricks"... unless it makes a scala solution shorter than any other. :)

... the comment you linked links further to https://codegolf.stackexchange.com/questions/3885/tips-for-golfing-in-scala , where the accepted answer suggests to use Scala's _ where possible, however, without answering the question whether this is acceptable for the outermost function definition :)

Labyrinth, 12 bytes
",)@
" (
..:

Try it online!
I have just discovered this language so this answer may be notably improved...

Nicely done, my first thought was the same (only "," instead of "",), I've managed an eleven now - could there be a ten or better?

Stax, 2 bytes
c\

Run and debug it at staxlang.xyz!
Copy. Zip. Implicit print.

R, 50 33 bytes
-17 bytes thanks to Giuseppe

function(a)gsub('(.)','\\1\\1',a)

Try it online!

gsub('(.)','\\1\\1',a)?

I don't only check CG.SE two seconds after you post, I check all the time, haha, I should probably cut back a little.

@Giuseppe No idea how that works, but it does.

Oh, well gsub does regular expression replacement -- replaces a single character match (.) in capture group 1 with two copies of capture group 1 \\1\\1, for all possible matches, as opposed to sub which only does one.

@Giuseppe Should this be submitted as your own answer since it is a completely different solution than what I came up with?

nah, I already wrote two answers. You take the rep and keep on golfing :-)

Turing Machine But Way Worse, 475 bytes
0 0 0 1 1 0 0
1 0 1 1 1 0 0
0 1 0 1 2 0 0
1 1 1 1 a 0 0
0 2 0 1 3 0 0
1 2 1 1 b 0 0
0 3 0 1 4 0 0
1 3 1 1 c 0 0
0 4 0 1 5 0 0
1 4 1 1 d 0 0
0 5 0 1 6 0 0
1 5 1 1 e 0 0
0 6 0 1 7 0 0
1 6 1 1 f 0 0
0 7 0 1 g 0 0
1 7 1 1 g 0 0
0 a 0 1 b 0 0
1 a 1 1 b 0 0
0 b 0 1 c 0 0
1 b 1 1 c 0 0
0 c 0 1 d 0 0
1 c 1 1 d 0 0
0 d 0 1 e 0 0
1 d 1 1 e 0 0
0 e 0 1 f 0 0
1 e 1 1 f 0 0
0 f 0 0 h 1 0
1 f 1 0 h 1 0
0 h 0 1 i 1 0
1 h 1 1 i 1 0
0 i 0 1 0 0 0
1 i 1 1 0 0 0
0 g 0 1 g 0 1
1 g 1 1 g 0 1

Trivial modification of this answer
Try it online!

Retina, 4 bytes

$<&

Try it online!
Matches the empty string (i.e. the position before/after each character) and inserts the string between this and the previous match (which is always exactly the previous character; except for the first match where it does nothing).

Labyrinth, 11 bytes
,:
"~~."
 @

Try it online!
How?
, - takes a byte from STDIN and pushes its ordinal onto the stack (0-255)
  -                                    unless EOF which pushes -1
: - duplicates the top of the stack [TOS]
~ - bitwise NOT TOS (-1 becomes 0, n becomes -n-1)
  -   4-neighbours: if TOS=0 go forward to @
  -                 if TOS<0 go left to ~
  -                 if TOS>0 go right to " (never the case)
@ - exits the program, otherwise...
~ - bitwise NOT TOS (undoes the effect of the previous ~)
. - print and discard TOS (mod 256) as an ASCII character
" - no-op
  -   We've hit a wall, turn around!
. - print and discard TOS (mod 256) as an ASCII character
~ - bitwise NOT TOS (stack starts with an infinite supply of 0s, so now TOS=-1)
~ - bitwise NOT TOS (and now TOS=0 again)
  -   4-neighbours, but TOS=0 takes us forward to "
" - no-op
  -   ...and we're back at the starting ,
  -      facing right, with infinite 0s on the stack - just like the start

JavaScript (V8), 28 bytes
a=>[...a].map(p=>p+p).join``

Try it online!

Leaf Lang, 86 bytes
Note: The interpreter does not have a stable release. If I introduce a breaking change I will update this post :)
import"string.lf"argv reverse splitString 0=0=while:o:o:o:o:o o print o print 0=0=stop

Explaination:
0                  - push 0 to the top of stack
import "string.lf" - import stdlib's string.lf
argv               - add all of argv in order to the stack
reverse            - reverse string on top of stack (part of string.lf)
splitString        - split a string into chars (part of string.lf)
0 = 0 =            - this checks to see if the top value of the stack is a zero
while              - runs while the top value on the stack is true (1)
:o:o:o:o           - the language has pop as a keyword but :o is 1 char less and can be put side by side.
:o                 - grab the first letter on top of the stack and store in o
o                  - push the value in o on top of the stack
print              - print top value on stack with no newline
o                  - push the value in o on top of the stack
print              - print top value on stack with no newline
0 = 0 =            - check if the next value on the stack is not a zero
stop               - required to end while loop

Degolfed:
import "string.lf"

# [0, 'o', 'l', 'l', 'e', 'h']
0 argv reverse splitString

0 = 0 = while pop pop pop pop
    : current_char
    current_char print current_char print
    0 = 0 =
stop
```

Whitespace, 33 bytes
[N
S S N
_Create_Label_LOOP][S S S N
_Push_0][S N
S _Duplicate_0][T   N
T   S _Read_STDIN_as_integer][T T   T   _Retrieve][S N
S _Duplicate_input][T   N
S S _Output_as_character][T N
S S _Output_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Start LOOP:
  Character c = STDIN as character
  Print c
  Print c
  Go to next iteration of LOOP

This language is Bizzare!

@AJFaraday :D It's perfect for some source-code and polyglot tagged challenges, though. ;) And this answer is quite straight-forward tbh. You can take a look at some of my other answers in Whitespace for harder examples.

Wolfram Language (Mathematica), 13 11 bytes
-2 thanks to LegionMammal978
#~Riffle~#&

Try it online!
Takes and returns an array of characters.

I believe the more straightforward #~Riffle~#& would be a valid 11-byte solution (taking and returning a character list).

Perl 6, 13 11 bytes
{S:g{.}x=2}

Try it online!
Anonymous code block that takes a string and returns a string by replacing each character with twice of itself.

Brain-Flak, 48 bytes
([]){{}({}<>)<>([])}{}<>([]){{}(({}<>))<>([])}<>

Try it online!
This code has two main sections.  The first just reverses the string:
([]){{}({}<>)<>([])}{}<>

The second is nearly identical, it reverses the string and doubles the characters in place
([]){{}(({}<>))<>([])}{}<>

The reason we need to reverse things is that we need to touch every element of the strings in order to make the output.  Since Brain-Flak uses a stack model touching each character means popping all of the elements and pushing them.  Because of the FIFO manner of a stack this means each time this is done you reverse the string.  The reversing issue is not present in Brain-Flueue below.
Brain-Flueue, 28 bytes
([]<>){({}[()])<>(({}))<>}<>

Try it online!
Since queues are first in last out all we need to do in Brain-Flueue is iterate through the entire string doubling every character in place.  However this does make it harder to iterate through the entire stack.  In Brain-Flak we could just go until the stack height is zero however with a queue, pushing something puts it on the bottom of the queue essentially losing it.  Instead we use the second queue to keep track of the number of operations we need.  This makes are main loop look like:
([]<>){({}[()])<>...<>}<>

With the contents being the meager
(({}))

Just for fun, both of these answers could get a lot shorter if there were no null bytes in the input (ascii value zero)
Brain-Flak, 26 bytes
{({}<>)<>}<>{(({}<>))<>}<>

Try it online!
Brain-Flueue, 14 bytes
{(({}<>))<>}<>

Try it online!

44 bytes handling nulls

Befunge-93, 8 bytes
~:1+%:,,

Try it online!
For each character in input, outputs c%(c+1) as a character twice. This makes the program calculate -1%0 on EOF (-1), which terminates it.

Husk, 3 bytes
ṁR2

Try it online!

The solution I came up with was ṁ´e

Ṙ2 is -1 byte.

Flobnar, 11 bytes
\\@
|~
,e
:

Try it online!
This feels golfable.

upvoted for name alone

!@#$%^&*()_+, 12 bytes
*^(_^_!@@*^)

Try it online! If programs could terminate with an error, *(!@@*) works for 7 bytes.
Explanation
*^(_^_!@@*^)
*^                 take input, add 1
  (        )       loop until top of stack is 0
   _^_             subtract 1
      !            duplicate
       @@          output twice
         *^        take input, add 1

How do you pronounce !@#$%^&*()_+ ??

@roblogic There are two canonical pronunciations. (1) "ek-nid-puc-ay-al-rulp" (2) "dang"

C (gcc), 62 41 bytes
f(char*a){for(;putchar(putchar(*a++)););}

Try it online!
This takes in input as the first arg, and outputs a NULL-terminated string to stdout. Not sure if the NULLs are a big deal. If you read the string properly, you'll stop after the first one ;)
Original without using a footer

C# (Visual C# Interactive Compiler), 26 bytes
s=>s.SelectMany(c=>c+""+c)

Try it online!

You could just use s=>s.Select(c=>c+""+c) instead to save 4 bytes

I considered that, but the signature would be kind of strange, since it is converting from IEnumerable<char> to IEnumerable<string> and other answers had avoided this.

Wait, this answer is actually wrong right now.. The output is a list of 2-char strings, which is neither a string nor list of chars/single-char strings. I.e. "abc" results in ["aa","bb","cc"]. The additional join in the print makes it aabbcc, but that should then be counted towards the byte-count. If ["aa","bb","cc"] would have been an acceptable output, I would have a few 1-byter solutions for my 05AB1E answer..

@KevinCruijssen - the output is a list of characters. If you use Select you get a list of 2-character strings. SelectMany flattens each element and connects them. The output is a long list of characters.

@dana Ah ok, thanks for explaining. Then your code is indeed correct, but ZacFaragher's suggestion would give the incorrect result. Based on your response to him I thought the problem was outputting a list of single-char strings instead of actual chars, in which case you could also use single-char strings as IEnumerable<string> as both in- AND output. Didn't knew SelectMany would flatten in the process. In that case my initial upvote remains (couldn't retract it earlier anyway ;p).

25 bytes

@LiefdeWen - That creates an array of 2-length strings whereas the current answer outputs an array of characters. I knot it's subtle, but in looking at the comments I think this difference makes 2-length strings invalid output

@dana Oh yeah, you are right

Pepe, 19 bytes
REEerEErReEeReEeree

Try it online!
Explanation:
REEe # Input as str -> (R)
rEE # Create loop labelled 0 -> (r)
  rReEe # Output as char -> (R)
        # r flag: don't pop
  ReEe # Output as char and pop -> (R)
ree # Loop while (R) != 0

Arn, 5 bytes
|{|}\

Since this is <6 bytes I can't compress it
Explained
      \ Fold with...
| Concatenation after...
  { Mapping...
    | And concatenating _ and _
  } End map

Fold's required input is automatically assumed to be _ (initialized as STDIN). Type casting automatic, output automatic.

The answer that I can't understand how it works, even after explanation! (Just like Arnauld's explanations) +1

Vyxal, 1 byte
Y

Try it Online!
Yet another trivial answer. Y interleaves the input string with itself. It’s good that Vyxal can tie with Jelly and beat 05AB1E in matters of triviality.

Due to the way Y works, the s flag is unnecessary.

Kotlin, 48 35 bytes
35 bytes from 48 bytes thanks to @user
{it.map{"$it$it"}.joinToString("")}

Not much to it, just that it.map() returns a CharArray so you have to joinToString() it.
Kotlin Playground Link(Would've been TIO but TIO has issues with kotlin.)

Welcome to Code Golf! You can also use something like {it.map{"$it$it"}.joinToString("")} (lambdas are allowed according to a meta consensus).

FYI there's already a few Kotlin solutions. (although we don't prohibit posting your own attempts) https://codegolf.stackexchange.com/search?q=inquestion%3A188988+Kotlin (I think there's also the graduation userscript that shows a leader board under every questions, but I don't use it myself) cc @user

@user202729 Even if we did prohibit duplicate answers, this one's different from the other two, and it could be made shorter than both of them with a lambda. I do agree with you that one should check pre-existing answers first, though.

@user Thanks for the help, I've edited that in.

Python 3.8, 31 bytes
for x in input():print(end=x*2)

Try it online!

Excel, 43 bytes
=CONCAT(MID(A1,SEQUENCE(LEN(A1),2,,0.5),1))

Link to Spreadsheet

You can mark this as 42 bytes by removing the 0 in 0.5 - Excel will autoformat this back into your answer, but changes made by autoformatting are not counted in bytecounts

Binary Pi Calculus, 5 bytes
0x37 0xA7 0xB2 0x7B 0x00

I don't know if there is an interpreter for BPC.  If there is one, I'd appreciate if someone let me know.
Explanation
0x37     0xA7     0xB2     0x7B     0x00
00110111 10100111 10110010 01111011 00000000
0011011110100111101100100111101100000 000
001                                   Run the following on an infinite number of threads:
   1011110                            Read from free channel 0 into bound variable 0
          100     1100                Write bound variable 0...
             11110                    ...to free channel 1
                      100111101100    Do so again
                                  000 End the process

BPC technically does not have I/O capabilities.  Instead, I use the global names 0 and 1 for STDIN and STDOUT, respectively (these numbers are, incidentally, the file descriptors for STDIN and STDOUT in most 'nix operating systems)

Rust, 38 bytes
|x:&str|x.find(|c|print!("{c}{c}")>())

Playground
This takes advantage of Rust's new formatting features (capturing identifers automatically) as well as the fact that () implements Ord and can be compared to itself. Basically this solution searches the string for a character that matches a predicate, but that predicate outputs the character twice and returns false.

Python, 31 bytes
lambda x:''.join(i*2for i in x)

This uses the shorthand for a generator comprehension. It will loop through every character in x and double it. sum won't work for str, so I took the advice from the error and used ''.join.

Nice, never even knew this existed

Prolog (SWI), 47 bytes
\[X|A]-->[X,X],\A.
\[]-->[].
X+Y:-phrase(\X,Y).

Try it online!
-8 from Steffan.
Requires the prolog system to use atoms as characters for double quoted strings(Scryer prolog and GNU Prolog do this by default).
:- set_prolog_flag(double_quotes, chars).

The DCG alone is 34 bytes, which is still shorter than the 35 byte version of Thoozee's answer, which is d([A|X],[A,A|Y]):-d(X,Y). d([],[]).

47 bytes with operators: Try it online!

Also you could exclude the flag and have I/O as list of charcodes, and use the backtick literal: Try it online!

It's still much shorter to do it without phrase, e.g. 24 bytes

feel free to post

D, 57 bytes
Nothing special, just using the std.algorithm's fold function to add a character twice every iteration. There's probably a more efficient way to do this but this one's pretty concise.
import std;auto d(dstring s){return s.fold!"a~b~b"(""d);}

Try it online!

Uiua, 5 chars / 9 bytes
♭⍉[.]

Try it online!
Uiua is a fusion of the stack-based and array-oriented paradigms. It is read right-to-left.
[.] duplicates the top of the stack (the input string) and puts both into an array.
⍉ transposes the array so the 2 input strings go top down (every row contains 2 of a char).
♭ deshapes the array, turning it back into a string.

-1 using couple: ♭⍉⊟.

JavaScript (V8), 28 bytes
s=>[...s].map(n=>n+n).join``

Try it online!

Ook!, 48 bytes
Ook.Ook!Ook!Ook?Ook!Ook.Ook!Ook.Ook.Ook!Ook?Ook!

This is just a port of my brainfuck answer. Unfortunately there is no support for Ook! on TIO, but you can use this online interpreter.

K (oK), 5 bytes
Solution:
,/2#'

Try it online!
Explanation:
,/2#' / the solution
  2#' / 2 take (#) each
,/    / flatten

{2}# also works

Will update once I'm off mobile, can you explain how/why this one works? Why doesn't the lambda just return 2?

m#l is filter (m monad, l list) - equivalent to l@&m'l

Kotlin, 44 bytes
{s:String->s.map{"$it$it"}.joinToString("")}

Try it online!

MathGolf, 1 byte
^

Try it online!
Same as the Jelly answer, zip works on a character level for strings. Implicitly pops the input twice, and zips it with itself to produce a string. The first idea I had was m_ (map each character to duplicate), which produces identical output.

QuadR, 4 bytes
.
&&

Try it online!
. replace each character
&& with itself followed by itself

Keg, 11 7 6 4 3 bytes
(⑩,

Explanation
(   # Repeat length of stack times:
 ⑩  # Print without popping the top of the stack
  , # Print with popping

Try It Online!

I'm impressed! Could not have golfed it that much! About TIO for Keg: how would I go around doing that... I know that it is to be done via the chat room, but I don't know if a direct request from someone who has never had any involvement in the room would be perceived as rude.

Also, how would implicit input for Keg sound?

@Jono2906 That definitely wouldn't be rude! Leaving a ping to Dennis in talk.tryitonline.net with a link to the interpreter should be enough to get Keg on tio :)

@A__ Try it online!

This doesn't output anything now?

Waiting Jono 2906 to fix it...

Try it online! - 3 bytes

Gema, 5 characters
?=?$0

Sample run:
bash-5.0$ gema '?=?$0' <<< 'Double speak!'
DDoouubbllee  ssppeeaakk!!

Try it online!

T-SQL 2008, 78 bytes
DECLARE @ varchar(max)='Double speak!'

,@z int=1WHILE @z<=len(@)SELECT
@=stuff(@,@z,0,substring(@,@z,1)),@z+=2PRINT @

Try it online

Standard ML (MLton), 35 bytes
String.translate(fn c=>str c^str c)

Try it online!
The function translate from the String library has the following type:
translate : (char -> string) -> string -> string

Thus, given a function that takes a char c, converts it to a singleton string twice with str c and concatenates both with ^, we get the required functionality.

Oracle SQL, 43 bytes
select regexp_replace(x,'(.)','\1\1')from t

It works with an assumption that input data is stored in a table t(x), e.g.
with t(x) as (select 'Double speak' from dual)

Gaia, 1 byte
Z

Try it online!
Z interleaves two strings (or lists); implicitly takes the input as both arguments.

Factor, 32 bytes
: f ( s -- s ) dup zip "" join ;

Try it online!

jq (-Rrj), 12 characters
(./"")[]|.+.

Sample run:
bash-5.0$ jq -Rrj '(./"")[]|.+.' <<< 'D0uB!e'
DD00uuBB!!ee

Try it online!

Shakespeare Programming Language, 238 164 bytes
,.Ajax,.Puck,.Act I:.Scene I:.[Enter Ajax and Puck]Ajax:Open mind.Let usScene V.Scene V:.Ajax:Be you better than I?If sospeak thy.Speak thy.Open mind.Let usScene V.

Try it online!
Boy, golfing in SPL does seem ugly...

Lots of bytes saved after Veskah pointed me to the SPL golfing tips. :-)

Gotta use Ajax and Puck. You can also omit a ton of non-essential words for big savings, though it does lose some of the SPL charm when you do.

An alternative algorithm can be much shorter.

@NieDzejkob Nice one, I tried something similar but the interpreter said that my characters were already on scene when I tried to loop, so I had to introduce two scenes.

@Charlie I'm also using two scenes. I'm about to integrate a -3 byte improvement from Jo King that removes the scene, though.

You don't need the first explicit scene transition, and I'm not sure what the conditional is about, since you terminate with an error anyway? You only do if so for the first output, but not the second, nor the scene transition

@JoKing yes, I noticed that, but if I keep on golfing my answer will be the same as NieDzejkob's...

Red, 43 bytes
func[s][t:""foreach c s[t: rejoin[t c c]]t]

Try it online!

Z80Golf, 10 bytes
00000000: cd03 8030 0176 ffff 18f6                 ...0.v....

Try it online!
Corresponding assembly:
start:
    call $8003 ; input
    jr nc, no_halt
    halt
no_halt:
    rst $38 ; nop-slide to $8000 - output
    rst $38
    jr start

Triangularity, 17 bytes
..)..
.IMD.
+}""J

Try it online!

Pip, 17 16 13 11 bytes
Fi,#aL2Oa@i

Try it online!

Zsh, 29 bytes
s=(${(s::)1})
<<<${(j::)s:^s}

Try it online!
I love parameter expansion flags:
s=(${(s::)1})
   ${     1}    # first argument
     (s::)      # split into characters: (s:foo:) splits on the string "foo"
s=(         )   # capture as array $s

<<<${(j::)s:^s}
   ${     s:^s} # zip array s with array s
     (j::)      # join on empty string (opposite of s::)
<<<             # print to stdout

Honorable mention, which would be 27 bytes... if not for the required 20 extra bytes to setopt extendedglob:
setopt extendedglob
<<<${1//(#m)?/$MATCH$MATCH}

This is basically the same as sed 's/./&&/g'<<<$1, but with builtins only.
Try it online!

I was all set up to try zsh but then you made this!

You don't need to include the setopt extendedglob - you can add it as a command line flag to zsh: --extendedglob for no extra bytes

Alternative (29)

@pxeger Yeah, I didn't start answering with zsh -oextendedglob with that rule until a little after this answer. Also, your alternative doesn't double backslashes.

@GammaFunction that can be fixed with -o bsd_echo

Lua, 32 31 bytes
print(((...):gsub('.','%0%0')))

Try it online!
Full program, take input as command line argument. Explanation is fairly trivial:
print(             -- Print result
    (              -- Drop second result (count of replacements, length of string for us)
        (...)      -- Take first cmd argument
        :gsub(     -- Do replacement:
            '.',   -- Take each character
            '%0%0' -- and replace it with itself (whole match) repeated twice
        )

    )
)
```

C (gcc), 57 56 bytes
Thanks to ceilingcat and gastropher for the suggestions.
The string is modified in-place, so the buffer holding the string needs to be big enough first.
i;f(char*s){for(i=strlen(s)+1;i--;s[i-~i]=s[i*2]=s[i]);}

Try it online!
C version with allocated string, 73 71 bytes
If the string buffer can't be assumed to be big enough (or writable), this version allocates a buffer to return.
f(s,t,u)char*s,*t;{for(u=t=malloc(strlen(s)*3);*t++=*s;*t++=*s++);s=u;}

Try it online!

Far as I could tell, there is no rule against wastefulness, so you could do malloc(strlen(s)*3) in the allocated string version to save two bytes.

You can save 13 bytes by using recursion in your in place modified version: x;f(char*s){x++;*s&&f(s+1);s[--x]=s[x]=*s;}

Swift 5, 30 bytes
thanks to @Mr.Xcoder for -14 bytes
{a in a.flatMap{"\($0)\($0)"}}
Try it online!

Welcome to PPCG, nice answer! You can drop let x= and put it in the header for -6 bytes.

@Mr.Xcoder like this? Try it online!

Yes, precisely.

PHP, 37 32 bytes
-2 bytes by removing PHP start tag <? and adding it in header per gwaugh's suggestion
-3 bytes thanks to great idea of gwaugh and eliminating the need for !='' check
for(;$l.=$l=$argn[$i++];)echo$l;

Try it online!

You don't need to include the opening <? in your byte count (-2 bytes).  You can also -3 more bytes this way for 32 bytes.

@gwaugh Thanks for the great idea, edited.

I don't believe you can omit the ending semicolon.  As a standalone, it must still be legal PHP and run as php -r "echo 'foo';".

@gwaugh I assumed that since we can remove the starting tag, same goes for the end tag. Added semicolon and 1 byte back.

The semicolon is part of the preceeding statement, so is required syntax.  There is nothing to prohibit from using a close tag ?> as long as it's included in your score. If you do, then yes it's valid to omit the last semicolon, however the general consensus is you can't use a close tag unless you have a corresponding open tag. Occasionally this is helpful: example because in that case it's shorter than an echo.

Gaia, 4 3 bytes
:¦$

Basically just maps the duplicate instruction to the input string, then turns the returned list into a string
Edit: turns out there was already a 1 byte answer in Gaia for this question that I missed, so my solution isn't that great
How it works
:   Duplicate
¦   Map to each character of the input string
$   Convert the returned list to a string
Auto outputs stack

Try it Online!

You don't need @ because the interpreter will implicitly push values onto the stack if needed, which is why Z works just fine.

Oh wow, I didn't realise that, my solution is really sub-optimal

Well, I've been golfing in Gaia a bit; this is still quite good!

there's also 2&.

reading through the docs for Gaia is annoying, especially since the interpreter is rather buggy.

Piet, 20 codels
If you are using npiet, you might want to use the -q option to stop the interpreter from printing a prompt for each character.

Rundown
If STDIN contains no character, Piet's input functions will not lock or throw an error, but simply fail quietly. To know if we reached the end of the string, we therefore push a sentinel 0 to the stack to detect if nothing was read.
In pseudo code:
1. Push 1 to stack
2. Perform NOT on top of stack
3. Attempt to read character
4. Duplicate top of stack, twice.
5. Perform NOT on top of stack, twice,
   leaving a 1 if character was read, 0 otherwise.
6. Turn Direction Pointer as many steps as value on top of stack.
7. If we turn, print character, twice, and go to start
8. If we do not turn, get caught in exit block. (Bottom left corner.)

Poetic, 46 49 bytes
+3 bytes to account for inputs that are longer than the tape will allow (unlikely, but possible).
enduring a tragedy,knowing a way i am,troubles me

Try it online!
Poetic is an esolang I created in 2018 for a class project. It's basically brainfuck with word-lengths instead of symbols.
The point of the language is to allow for programs to be written in free-verse poetry. I encourage you all to try it out sometime!

Forth (gforth), 39 bytes
: f bounds ?do i 1 type i 1 type loop ;

Try it online!
Beats NieDzejkob's submission by one byte. If we don't care empty strings, we can safely remove the ? in ?do, making it 38 bytes.
A function that takes a string in the standard representation (addr, length), and prints the result to the console.
How it works
gforth documentation about bounds
: f ( addr len -- )
  bounds ?do        \ Iterate through char addresses..
    i 1 type        \   Print one char at the address
    i 1 type        \   One more time
  loop ;            \ End loop

Backhand, 5 bytes
i}o:

Try it online!
(note the trailing space) This should be the optimal answer, since all of io: are needed, 4 bytes needs at two movement modifiers to avoid getting stuck in two instruction loops, and no three byte permutation works.
Explanation:
i       Input
   :    Dupe
  o     Output
 }      Move back to output
  o     Output
   :    Unnecessary dupe
i       Beginning of loop again

Of course, for a suboptimal but ironic answer you could do:
vvii::oooo22jj

Try it online!
Which doubles up on every character.

SWI-Prolog, 87 bytes
I did not see any Prolog attempt, so I tried to make one.
d([A|X],[A,A|Y]):-d(X,Y). d([],[]). p(X,W):-string_codes(X,Y),d(Y,Z),string_codes(W,Z).
The predicate to be called is p:
?- p("Hello world!", X)
It produces (in SWI-Prolog online interpreter):
X = "HHeelllloo  wwoorrlldd!!";
Explanation
The code uses two different predicates: the first one (d) works with a list and duplicates every element in it.
d([A|X], [A,A|Y]) :- d(X, Y).
d([],[]).
As most of Prolog's predicates, it uses recursion to implement iteration over elements: the first line is the recursive step, while the second is the base step.
Duplication is obtained by forcing the head of the first argument to be equal to the "2-elements-head" of the second argument.
Unluckily, this is not enough to work with strings: in fact, predicate p serves as converter between strings and lists.
p(X,W) :- string_codes(X,Y), d(Y,Z), string_codes(W,Z).
Due to library names, this second predicate extends the solution by at least 22 unnecessary characters... So, if anyone could suggest me a way to get rid of those, or any general solution improvement, I'd be very grateful ^^
Note that you can still use d in a sort of "raw-mode", reducing the solution length to 35 bytes. However, the input is technically not a string.
?- d(['H','e','l','l','o',' ','w','o','r','l','d','!'],X)
Try it online!

Taxi, 390 342 335 bytes
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.[A]Go to Chop Suey:n 1 r 1 l 4 r 1 l.Switch to plan B i.Pickup a passenger going to Cyclone.Go to Zoom Zoom:n 1 l 3 r.Go to Cyclone:w.[C]Pickup a passenger going to Post Office.Switch to plan B i.Switch to plan C.[B]Go to Post Office:s 1 l 2 r 1 l.Switch to plan A.

Try it online!
Explanation/Ungolfed
    [Take input string]
Go to Post Office: west 1st left, 1st right, 1st left.
Pickup a passenger going to Chop Suey.

[loop]
    [If string as a passenger, split it]
Go to Chop Suey: north 1st right, 1st left, 4th right, 1st left.
    [At the end of the string, end the program]
Switch to plan end_loop if noone is waiting.
        [any character after end_loop is fine]
    [Duplicate first character left]
Pickup a passenger going to Cyclone.
Go to Zoom Zoom: north 1st left, 3rd right.
Go to Cyclone: west.
    [Pickup character twice]
[two]
Pickup a passenger going to the Post Office.
Switch to plan end_loop if noone is waiting.
Switch to plan two.
    [Prints characters or crashes program, you can't drive that way]
[end_loop]
Go to the Post Office: south 1st left, 2nd right, 1st left.
Switch to plan loop.

Comment
It does not even matter whether we tank at Zoom Zoom or Fueler Up, both are 335 bytes.
By tanking at Fueler Up we pay so much that we don't earn enough and are out of gas for string of length 86 or more.
However, even tanking at Zoom Zoom does not allow to drive infinitely, it probably stops at strings of a length around 129, I didn't test or solve this because it's an old answer.
Go to Post Office:w 1 l 1 r 1 l.Pickup a passenger going to Chop Suey.[A]Go to Fueler Up:n 1 r 1 l.Go to Chop Suey:n 3 r 1 l.Switch to plan B i.Pickup a passenger going to Cyclone.Go to Cyclone:n 1 l 3 l.[C]Pickup a passenger going to Post Office.Switch to plan B i.Switch to plan C.[B]Go to Post Office:s 1 l 2 r 1 l.Switch to plan A.

Try it online! (With a long string)

You can save four bytes by removing the quotation marks in the "Switch to plan" commands.

QBasic, 58 bytes
LINE INPUT s$
FOR i=1TO LEN(s$)*2
?MID$(s$,i/2+.1,1);
NEXT

Explanation
LINE INPUT reads all input characters until a newline into s$. We loop i from 1 up to twice the length of the string and output the i/2th character (rounded up) at each iteration. There's a slight hitch, in that QBasic rounds numbers with a fractional part of .5 up sometimes and down other times; adding a small amount like .1 is sufficient to round the halves up, while the whole numbers still get rounded back down.

Acc!!, 42 bytes
N
Count i while _/32 {
Write _
Write _
N
}

Try it online!
Reads one character at a time into the accumulator and outputs the accumulator twice for each character. Loops until it encounters something with an ASCII code less than 32 (newline or EOF).

naz, 34 32 bytes
2x1v1x1f0a0x1x2f1r3x1v1e2o2f0x2f

Works for any null-terminated input string.
Try it online!
Explanation (with 0x instructions removed)
2x1v             # Set variable 1 equal to 0
1x1f0a           # Function 1
                 # Add 0 to the register
1x2f1r3x1v1e2o2f # Function 2
                 # Read a byte of input and goto function 1 if it equals variable 1
                 # Otherwise, output twice and call function 2
2f               # Call function 2

Burlesque, 2 bytes
)J

Try it online!
) # Map (implicitly explode and apply to each character then concatenate)
J # Duplicate

Fortran (GFortran), 71 65 bytes
character(99)a
read*,a
print*,(a(i:i),a(i:i),i=1,len_trim(a))
end

Try it online!
Saved 6 bytes thanks to @roblogic pointing out that if the input is quoted it can be read as list-directed.
If we don't care about extra whitespace:
Fortran (GFortran), 56 bytes
character(99)a
read*,a
print*,(a(i:i),a(i:i),i=1,99)
end

Try it online!

Nice, I tried to use "proper" syntax for 100 bytes. https://codegolf.stackexchange.com/a/189152/15940

@roblogic I saw, that's what inspired me to beat it. To me, there's nothing wrong with implicit loops in very rare situations (Array assignment and printing), but in golf, anything goes.

the 56-byte solution will work correctly if you assume the input string is quoted. example

@roblogic Still prints out excess whitespace, but saves bytes on the main one.

Brainetry, 85 bytes
Golfed version inspired in the program that comes after:
a b c d e f
a b c d e f g h
a b c d e f g
a b c d e f g
a b c d e f
a b c d e f g h i

To try this online, head over to this link, copy&paste the code in the btry/replit.btry file and hit the green "Run" button.
Golfed from this program:
This is almost a cat program.
This is a double speak Brainetry cat program:
For every single character of input gotten
I am supposed to output two characters.
Doing this in Brainetry is easy.
Can I get a more difficult challenge, please ?

MAWP, 8 bytes
|0~[!;;]

Clones each character, pops from stack twice.
Try it!

Python 3, 36 35 bytes
print(''.join(x*2for x in input()))

Try it online!
Edit 1: Saved a byte

I think you can save one byte removing the space in x*2 for.

@DomHastings Brilliant. Did the change. Thanks!

Labyrinth, 9 8 bytes
 ,
.:@
:

Try it online!
Wins over Jonathan Allan's answer.
How it works
,    Start at the first meaningful instruction; push a char from stdin
:    Duplicate; on EOF, top is -1 so turn left and exit (@)
     otherwise, top is positive (printable ASCII) so turn right
.:.  Pop-print as char, dup, pop-print as char. Top is still the input char
:    Duplicate; turn to (,) since top is nonzero
,    This is a dead end so it runs again from the start, until EOF

Scala, 21 bytes
_./:("")(_+"".+(_)*2)

Try it online!

You might want to flatMap

@user here is already an answer using flatMap and when refactored into a lambda expression I think it has 22 bytes.

Oops, I didn't see that. I think you can still use flatMap, in fact you can make it 20 bytes that way. It's okay if you don't want to use it, though

BRASCA, 6 bytes
As of writing, there's no online interpreter yet.
EDIT: There is now.
,[:oo]

Try it online!
Explanation
<implicit input>      - Push STDIN to the stack
,                     - Reverse stack
 [   ]                - While non-zero:
  :oo                 -     Output the current character twice

Python 3, 43 bytes
def d(s,o=""):
	for c in s:o+=c+c
	return o

Try it online!

32 bytes

FYI there's already a few Python 3 solutions. (although we don't prohibit posting your own attempts) https://codegolf.stackexchange.com/search?q=inquestion%3A188988+Python (I think there's also the graduation userscript that shows a leader board under every questions, but I don't use it myself) cc @Lyxal

Julia 1.0, 20 18 bytes
!s=join([s...].^2)

Try it online!

Dis, 3 bytes.
}{{

Try it online!
How it works
} ( a=getchar;if a==EOF a=59048;)
 { ( if a==59048 exit; else putchar a%256; )
   { ( again)
( then keep program counter+=1 until 59048 where each cell from i=3 to 59048 is NOP;
   then pc=0 if pc is 59048)

TI-Basic, 52 37 39 bytes
For(I,1,2length(Ans),2
sub(Ans,1,I)+sub(Ans,I,1-I+length(Ans
End
Ans

Input is taken in Ans. Output is stored in Ans and displayed.

Vyxal, 4 2 bytes
2•

Try it Online!
Removed implicit input and output. Thanks @emanresu A
Doesn't beat Y but works nonetheless.

Nice! You don't need the ? or , due to implicit input/output.

Q, 7 bytes:
(,/)2#'

Explanation
      '          // Each operator
    2#           // Take two
(,/)             // Join over (aka raze)

Welcome to Code Golf! Nice answer.

Lexurgy, 28 bytes
The "canonical" way of duplicating characters (gemination in linguistics terms) in Lexurgy: capture a character and an empty string, and replace both with itself. The $$ matches the space literal between words on a newline-separated input.
a:
[]$1 *=>$1 $1
$$=>$$ $$

Javascript(Node.js), 64 57 55 bytes
-7 bytes thanks to Radvylf Programs
-2 bytes thanks to pxeger
This is my first code golf answer, so I know this could be improved.
s=>{eval("e='';for(var i in s){e+=s.at(i).repeat(2)};e")}

Attempt this online

Welcome to code golf! You can save some bytes by replacing (s) with s, shortening end to a single letter, and removing the {} around the for loop. You can also use a trick where instead of s=>{...;return end}, you do s=>eval("...;end") to save another byte.

The eval() tip Radvylf mentioned requires you to remove the {} around the function. Also, you can avoid the problem of having an extra 20 bytes on ATO by putting the running code in the Header and Footer: https://ato.pxeger.com/run?1=m70kLz8ldcHa5Py84vycVL2c_HQNjaWlJWm6FjfNi23tUssSczSUUm3V1a3T8os0yhKLFDIVMvMUijWrU7Vti_USSzQyNfWKUgtSgSwjzVrrVCVNiPYtmhrqxfm5qQolqcUlCsmJxanqmlCpBQsgNAA

33 bytes

C (clang), 43 chars
The function f is double speaking its string input.
f(char*a){*a&&f(a+!!putchar(putchar(*a)));}

Edit : saved 1 char by reusing the putchar output to eliminate a division, by ceilingcat.

Suggest printf("%c%1$c",*a)-1 instead of !!putchar(putchar(*a))

Rust, 114 bytes
fn main(){let mut b=format!("");std::io::stdin().read_line(&mut b).unwrap();for l in b.chars(){print!("{}{0}",l)}}

Rust is not a great golfing language given its focus on explicitness, but here's an answer anyway!
Normally one allocates a string using String::new(), but format!("") is two bytes shorter. I also use that the print macro can accept the index of the variable to print, so I avoid writing print!("{}{}",l,l), saving one byte.
Try it online!

Wolfram Language (Mathematica), 44 33 25 bytes
-11 bytes
-8 bytes
{#,#}&/@Characters@#<>""&

Mathematica is probably not the best choice for this given its verbose function names, but here's what I managed! The code works by first splitting its input into a list of characters, then it maps an anonymous function over it which replaces each character by a list of two copies. It then combines this list of lists of strings into the final string using <>"" which is an alias for StringJoin, which ignores all list structure.
Try it online!

Curry (PAKCS), 16 bytes
(>>=(\x->[x,x]))

Try it online!
very similar to haskell.

Python 3, 32 bytes
lambda s:''.join(c+c for c in s)

Try it online!

CellTail, 128 94 90 bytes
N,k&N..,N:1,k,[k];(k,b),N,N:1,k,b;(k,b),c&N..,1|N:1,k,b+[c];(_,a&N..,1)|(1,a&N..,_):1,a,1;

Since both the input and output need to be plain characters it was a bit tricky to prevent spiraling into a endless duplication loop. This version uses 1 as a marker to indicate it's neighbors don't need to split themselves further.
Try the online demo

yup, 9 7 bytes
*{:@@*}

Try it online.
Explanation:
*        # Push the first input-character
 {    }  # Loop as long as the top of the stack is NOT 0 (without popping):
         # (the initial `*` is to start the loop)
  :      #  Duplicate the character so there are two on the stack
   @@    #  Pop both, and print them as characters
     *   #  Push the next input-character for the next iteration
         #  (which will push 0 if there are no more input(-character)s left)

Arturo, 30 bytes
$[s][join map split s'c->c++c]

Try it

Java (OpenJDK 8), 88 87 bytes
g->{String d ="";for(int i=0;i<g.length();){d+=""+g.charAt(i)+g.charAt(i++);}return d;}

Try it online!
Ungolfed:
g->{
    String d ="";
    for (int i=0;i<g.length();) {
        d+=""g.charAt(i)+g.charAt(i++);
    }
return d;
};

I'm sure there's way to shorten it, at least it was my first attempt in PPCG.
-1 for @manatwork

Is shorter to force the casting (?) than to use 2 separate assignments; you can move the incrementation from for's 3rd argument to i's last usage: d+=""+g.charAt(i)+g.charAt(i++);

@manatwork Oh, okay. Done

48

@CuttingChipset, actually the point of using a single assignment was to be able to remove the for block's braces. But with Grimy's suggestion, now that's meaningless.

@manatwork but can I put his suggestion into the answer or what? It looks diametrically different than it is currently?

Well, that's up to you. Is frequently a dilemma whether to incorporate a radically different suggestion. We have no rule for that. Sometimes we keep the older solutions too at the bottom of answer, so they stay open for further discussions but are not scored.

If you want to use a similar answer to yours, check this: g->{var d="";for(char i=0,c;i<g.length();d+=c)d+=c=g.charAt(i++);return d;}

@Grimy 45 bytes by updating to Java 10 and using it's var.

@OlivierGrégoire You're link is incorrect, here the one you meant to link probably.

@KevinCruijssen Yes, that's the one. Sorry for the mix up

x86 machine code, 6 bytes
f:
  AC       LODSB
  AA       STOSB
  AA       STOSB
  E2 FB    LOOP  f
  C3       RET

Takes address of input string in SI, length of input string in CX, address of output string in DI. Should work in 16, 32 and 64-bit mode.
Try it online!

In 16-bit mode with far pointers the input string is in DS:SI and the output is in ES:DI of course.

The question specifies modifying a string (which implies in-place).  So you need to work from the end of the string backwards to not overwrite chars you haven't read yet.  I asked on the question for clarification.  See also discussion on the 8086 machine-code answer.

Heck, in 32-bit mode input is in ds:esi and output is in es:edi.

Bash, 72 bytes
s=$1;e(){ echo -n "${s:$i:1}";};for ((i=0;i<${#s};i++));do e;e;done;echo

If you don't have a bash terminal somewhere, this should work.

Nice try but I beat you to it.. :) https://codegolf.stackexchange.com/a/189043/15940.

Yeah, totally :)

PHP, 59 bytes
-1 bytes by @manatwork
function($g){foreach(str_split($g)as$v)$e.=$v.$v;return$e;}

Try it online!
Full program , 44 bytes
foreach(str_split(readline())as$v)echo$v.$v;

Try it online!

No need for the braces around foreach's block.

If you are submitting as a function you do have to include the function declaration (anonymous is fine) in your byte count: 65 bytes.

Though errors and notices are fine so you don't really need to initialize $e: 59 bytes.

Oh, welcome to PPCG by the way!

Thanks, I'm fixing my answer

If you don't mind outputting the STDOUT instead,you can use echo instead of return

I added a full program

Fortran (GFortran), 100 bytes
Another demonstration of fortran's concise and elegant string handling capabilities... not!!
Summary: declare S as a 99 character string. read S in string format '(A)'. iterate over the trimmed string length. print the i'th character a couple of times without a newline (TIL).
Try it Online!
character(99)S;read(*,'(A)')S;do i=1,len_trim(S)
write(*,'(A)',advance="no")S(i:i)//S(i:i);enddo;end

Twig, 66 bytes
This is just a simple "split, loop, output twice".
Splitting by 0 on a string is similar to splitting by '' (empty string).
{%macro a(s)%}{%for c in s|split(0)%}{{c~c}}{%endfor%}{%endmacro%}

You can try it on https://twigfiddle.com/ldxe0c.

Matlab >= r2015a, 16 bytes
@(x)repelem(x,2)

Credits to Giuseppe
Note: I haven't found an online interpreter for MATLAB; this answer correctly works with MATLAB r2015a.
Matlab <= r2014b, 23 bytes
@(x)char(kron(x,[1,1]))

Note: I haven't found an online interpreter for MATLAB; this answer correctly works with MATLAB r2014b.

Octave, 32 25 bytes
@(x)char(kron(x+0,[1,1]))

Try it online!
-7 bytes thanks to Giuseppe

Agda, 110 Bytes
Sorry, no online interpreter available because this is more of a proof checker.
So this was quite annoying since I tried not to use the standard library and thus had to explicitly define lists. Chars also don't exist by now, but the function is polymorphic, so it would work in this case.
data L(A : Set): Set where
 N : L A
 C : A → L A → L A
d :{A : _}→ L A → L A
d N = N
d(C x y) = C x(C x(d y))

Retina 0.8.2, 6 bytes
.
$&$&

Try it online! Not guaranteed to work with unprintable characters. Previous 8-byte version worked with newlines:
s`.
$&$&

Try it online!

You can remove the s`  now that the rules got changed.

@KevinCruijssen Thanks!

VDM-SL, 28 bytes
f(a)==conc[[x,x]|x in seq a]

Distributed enumeration of the sequence containing sequences of length 2 of repeated elements of a.

I don't think the output of your first solution is valid.

@Shaggy maybe, when I posted it there were other answers with similar output. I'll remove the first one

If you spot any others, leave them a similar comment ;)

Perl 6, 33 bytes
(@*ARGS[0].comb Xx 2).join.say

Comb splits our string into an array. The X meta operator applies the operator to it's right in a cross product fashion. So with the string "Double" it's doing ("D"x2, "o"x2, etc). Then we join the result and say it to print (with a newline).

Japt -m, 1 byte
²

Try it online

Was about to hit "Post" on my identical solution when the page refreshed with yours!

@Shaggy I knew this would be a race against you :-P

A race against everyone, nearly, on a challenge this trivial! Posted a 2 byte solution anyway.

Japt, 2 bytes
Oliver beat me to the straightforward, 1 byte solution.
íU

Try it
Interleaves the input with itself.

Bash, 58 39 bytes
Using only shell builtins, no fancy parsers like sed.
58 bytes: Try it online
a="$*";for((i=0;i<${#a};i++)){ x=${a:i:1};echo -n "$x$x";}
47 bytes: (via primo)
for((;i<${#1};)){ x=${1:i++:1};echo -n "$x$x";}

39 bytes: (by manatwork). Try it online
while read -N1 c;do echo -n "$c$c";done

Does not double % characters.

Good catch, fixed now (replaced printf with echo -n)

No need to reassign $*, just use $1. Initializing i=0 is unnecessary. i++ can be moved to x=${1:i++:1}.

A traditional read in while would be shorter and still using only Bash's own staff: Try it online!.

C# (Visual C# Interactive Compiler) with Regex†-flag, 24 bytes
†: /u:System.Text.RegularExpressions.Regex (flag is not in the header, so it won't mess up the leader-board)
Port of my Java 8 answer, so look there for an explanation.
s=>Replace(s,".","$0$0")

Try it online.

Anything we can do to make the flag text in the header shorter? It makes the language name column in the leader-board pretty wide. (maybe "C# (Visual C# Interactive Compiler) with /u:...* flag, 28 bytes" and a * /u:System.Text.RegularExpressions.Regex in the body?)

@JonathanAllan I've changed it. Will have to wait a few minutes before the API-date is updated to see if it works. EDIT: works. It's better readable now. ;)

Forth (gforth), 40 bytes
: x 0 ?do dup c@ dup emit emit 1+ loop ;

Try it online!
A byte can be saved by removing the ?, but that will break the handling of zero-length input.

CJam, 3 bytes
q:_

Try it online!

J, 2 bytes
2#

The verb "#", or "copy", copies its right argument the number of times specified by the left argument where the left argument is greater than or equal to zero and is either a single number or a vector of numbers of the same length as the first axis of the right argument.  So, we can copy things "zero" times to remove them:
   1 0 1 0 # 1 2 3 4

returns 1 3.
Try it online:
https://tio.run/##y/r//39qcka@gpGyukt@aVJOqkJxQWpitqI6138A

Snippets aren't allowed.  You solution needs to be assignable to a variable.  So eg 2 # ], Galen's answer, is allowable because you can write f=. 2#], but you cannot write f=.2#

><>, 9 bytes
i::0(?;oo

Try it online! I'm reasonably confident that this is optimal (barring solutions which terminate through errors; i:oo would be such a solution.)
Explanation
i::0(?;oo
i             takes one character of input      [c]
 ::           duplicates it twices              [c, c, c]
   0(?        if it's less than 0 (no input)    [c, c]
      ;       terminate
       oo     output twice                      []
              implicitly wrap to the beginning

If you can start with input on the stack (IIRC a command line option for one implementation), then you could do :oo for a solution with an error and l?!;:oo for a solution without. These are not tested, but I’m pretty sure they’re right.

Minkolang v.0.15, 7 bytes
od?.dOO

Try it here!
Explanation
od?.dOO
o            take one character of input
 d           duplicate top of stack
  ?.         terminate if its 0
    dOO      duplicate and output twice

8086/8088 machine code, 9 bytes
I couldn't resist.
ac       lodsb        Read DS:[SI] into AL, then increment SI.
aa       stosb        Write AL into ES:[DI], then increment DI.
3c 00    cmp al, 0    Is AL = 0?
74 03    je +5        If so, jump to the end of this loop.
aa       stosb        Write AL into ES:[DI], then increment DI.
eb f7    jmp -7       Jump to the beginning of this loop.

Assumptions:

The input string is a null-terminated string of bytes located at DS:SI.
There is an output string buffer located at ES:DI.
The output string buffer is large enough to hold the resulting string.
It's not necessary to tell the calling code the location of the output string buffer. If it is, add 2 bytes: 57 (push di) at the beginning and 5f (pop di) at the end. This assumes that the stack has 2 bytes free.
This code will be placed inline, so it's unnecessary to use an instruction to return. If this is false, add 1 byte: c3 (ret) at the end (after the 5f, if applicable).

Or 7 bytes with just: lodsb /   stosb /   stosb /   cmp al, 0 /   jne -7  It will give you two 0's at the end of the string, but can't see how that's not allowed since you're writing to a "large enough" buffer and will still be null terminated.

Or 6 bytes by combining the two ideas: lodsb /   stosb /   stosb /   dec ax /   jns -6

The question wording is pretty clear: It will modify this string.  Not return a copy, so asking the caller to pass a 2nd output arg is definitely bending the rules.  I asked for clarification on this.  re: omitting the ret: it doesn't say "function" but it does say "return" instead of just "produce".  To me that implies function, not inline block.

@gwaugh: dec ax only works if AH was known to be zero ahead of that.  That would cost an extra 2-byte instruction ahead of the loop to zero AH or AX.  You can't justify offloading that setup of a tmp reg to the "caller" in code-golf.  dec al wouldn't be safe and is 2 bytes anyway so we might as well just use cmp.

Anyway, to loop backwards I was thinking std then a loop like lodsb/2xstosb/loop/cld (with the caller passing a length in CX).  Although we probably need add si, cx and add di, cx first if the caller passes pointers to the start of the buffers.  lea di, [esi + ecx*2] costs 4 bytes (address-size prefix + SIB) so it's the same as 2x add di, cx.  I don't think there's a compact way to broadcast-load so we could do word stores.  32-bit mode for AVX2 vpbroadcastb xmm0, [esi] costs at least a 3-byte VEX prefix + opcode + ModRM.

@gwaugh: you only get to assume regs are in OS-initialized states if you're writing a complete program!!  If you assume AX=0, you also have to assume that SI and DI are zero, not already pointing to buffers.  re: ASCII: the question is telling us that out of the entire ASCII character set (which you can see at http://asciitable.com/), the string will only contain printable characters, not control chars or NUL (\0).  And not UTF-8 or any other multi-byte or variable-length encoding.  Anyway yes, this would allow dec al / jns but that's not smaller than test al,al.

@PeterCordes there was quite a spirited debate in the comments earlier about whether the challenge required handling ASCII 0-127 or 32-126. I was only saying that if the requirement did include handling ASCII NUL (\0) then technically this solution wouldn't work because it will end the string at \0. I believe the 32-126 won out, (though I'd have preferred to see that stated more explicitly).

Kotlin, 47 bytes
{(0..it.length-1).fold(""){s,c->s+it[c]+it[c]}}

Try it online!

Starry, 14 bytes
` , + + + . .'

Try it online!

33, 8 bytes
P[ktppP]

Try it online!
Or not. How do you get a language on TIO?
The input string has to be null-terminated.
Explanation:
P     P  | Get input character
 [     ] | While it isn't a null character:
  kt     | - Put it in the string register
    pp   | - Print it twice

You request to have the language added to TIO at https://chat.stackexchange.com/rooms/44255/talk-tryitonline-net. Thats what I'm doing at least (with my own language that is).

Cubix, 9 bytes
oU;?Av/@o

Try it online!
Mapped onto a cube
    o U
    ; ?
A v / @ o . . .
. . . . . . . .
    . .
    . .

Watch it run

A Put all the input onto the stack
v Redirect around the cube and start of the print loop
o? Output the character for the stack value and test value
@ If test is negative (EOI), halt
Uo;/ If test is positive, u-turn to the left, output character again, pop from stack and reflect onto the start of the print loop.

K (ngn/k), 5 bytes
,/2#'

Try it online!

the above is an expression that will take (#) 2 copies of each (') letter and return a list where each element is a 2-char list, e.g.
("DD";"oo";"uu";"bb";"ll";"ee";"  ";"ss";"pp";"ee";"aa";"kk";"!!")

,/ is "join over", and flattens the list. we read the expression as "join over 2 take each string". with the string passed right-side we get:
  ,/2#'"Double speak!"
"DDoouubbllee  ssppeeaakk!!"

{2}# works too. see other answers

AsciiDots, 27 21 bytes
.>#a?**>$_a#
 \---/\/

Note that this halts in an error, which is allowed.
-6 bytes by getting rid of whitespace and not using warps.
Try it online!

Kipple (cipple), 28 bytes
(i>ac<0>b(a-1b+1c+1a?)b>o<c)

It's actually suprisingly difficult to duplicate stack items in Kipple
Expanation
(i>ac<0>b(a-1b+1c+1a?)b>o<c) Full program

(i                         ) Loops until the input stack is empty
 i>a                         Push the top item of the input stack to stack A
    cb                    Push 0's to stack B and C
         (a-1b+1c+1a?)       A loop that basically pushes the top of stack A to stack B and C
                      b>o<c  Push the top of stack B and stack C to the output stack

Try it online!

MathGolf, 2 bytes
I hope this isn't a duplicate. (Great, it isn't.)
_^

Explanation
_  Duplicate the implicit input
 ^ Zip

Try it online!

Python 3, 31 bytes
for t in input():print(t,end=t)

a simple program of python
for t in input():

asking for the input, and doing a for loop for every char in the string.
print(t,end=t)

print the character, and then close the line with the same character.

Same as A _'s revised old solution posted 83 days earlier.

Hexadecimal Stacking Pseudo-Assembly Language, 60 bytes
000000100000420000400000420000400000030000040000140000010000

Try it online!
000000 Label start:
100000 read character
420000 load it into register
400000 push it on the stack another time
420000 load it into register
400000 push it on the stack another time
030000 ignore next command if top of stack is non-zero
040000 end program
140000 print string
010000 go to start

W j, 5 2 bytes
+M

If you want to specify your input, you need to split your input into a list of individual characters before you do your job. (If that disobeys the rules, I will implement a flag that does this job for the writer. (Flags don't count in bytecount.))
Say your input is abcdef. Find imps.py and change those variables:
read = [["a","b","c","d","e","f"]]

prog = '+M'

Explanation
Lots of implicit stuff here. Expanded program:
aaa+M

The + requires 2 inputs and M only provides a single input. Therefore two 'a''s are prepended.

The M only has 1 input required left, so a single 'a' is prepended.

a     % The Implicit input
    M % Map every item of this input with...
 aa   % This every item with this every item...
   +  % Concatenated together

% Implicit Output
j % Join the output without a separator

Wren, 24 bytes
Fn.new{|s|s.map{|n|n+n}}

Try it online!
For every item in the list, return every item concatenated with itself.

R, 61 bytes
function(x){paste0(rep(strsplit(x,"")[[1]],e=2),collapse="")}

Try it online!

Bash, 45 bytes
while IFS= read -n1 c;do printf %s"$c$c";done

Try it online!

Yeah I removed this part. Btw. I'm not sure if it's a valid solution, because the string is not modified but a copy is printed.

@JoKing: You are probably right.

GolfScript, 4 bytes
{.}%

Try it online!
Takes an input, which it treats as a list of characters, and maps . (push top item of stack to stack) over them.

MIT-Scheme 10.*, 52 bytes
(lambda(x)(string-map(lambda(y)(make-string 2 y))x))

MIT-Scheme 10.* apparently has the new string-map which simplifies my earlier approach listed below. The only difference is that make-string is used to convert the character argument into a string and duplicate it.
74 bytes
This is the older solution for MIT-Scheme 9.* before string-map was introduced.
(lambda(x)(list->string(append-map(lambda(k)(list k k))(string->list x))))

This is an anonymous lambda that takes the input as a string, converts it to a list so that it can be mapped (I don't know of another way to do the same), replicating each character and joining it together in one list, after which it is converted back into a string.

Pip, 4 bytes
aWVa

Try it online!
The operator WV ("weave") takes two iterables and interleaves their elements. In this case, weaving the input string with itself produces the desired output.

Rexx (Regina), 41 bytes
I just realized the rules specifically state "It will modify this string, duplicating every character." Since the newline is part of the string, I will now leave it in the string and duplicate it, thus reducing my code size to 42 bytes (according to ls -l, TIO says 41).
b=''
DO 80
a=CHARIN()
b=b||a||a
END
SAY b

Try it online!
Old 60 byte version which strips newlines (or CRs depending on your OS.)
b=''
DO 80
a=CHARIN()
b=b||a||a
END
SAY LEFT(b,LENGTH(b)-2)

Alternate last line (same number of bytes):
SAY STRIP(b,,X2C('0a'))

Do 80 iterations, read a char into var a, concatenate two a's onto the end of b during each loop, output the string minus the two newlines or CRs (need to modify for AmigaOS/AROS because it uses CR-LF for line terminators.)
62 byte original version:
DO 80
a=CHARIN()
x=CHAROUT(,a)CHAROUT(,a)
END

Read up to 80 chars from stdin into string var a, write 'a' to stdout twice for each char read in.

You can use Try it online! which has Rexx available.

Thanks for the link.

Forth, (GForth) 55 bytes
: d pad 80 accept 0 do pad i + c@ dup emit emit loop ;

Usage: d [enter]
This text will be doubled. [enter]
Online Forth interpreter
'accept' takes a line of up to 80 chars into pad, then the do loop
fetches chars from the pad, duplicates them and emits them to the terminal.

Elixir, 26 bytes
"#{for<<c<-s>>,do: [c,c]}"

Try it online!

PHP, 37 bytes
while($c=$s[$i++])$a.=$c.$c;return$a;

Try it online!

Kite, 111 94 79 bytes
Really surprised that nobody has used Kite before on CGCC... it's a really easy to learn language.
method d(a)[(a|split("")<-method(a)[a+a;])<|method(a,b)[a|str*a|bool|int+b;];];

Test suite:
method d(a)[(a|split("")<-method(a)[a+a;])<|method(a,b)[a|str*a|bool|int+b;];];

(d("abc"))|print;

(d("Double speak"))|print;

FEU, 12 bytes
s/(.)/\1\1/g

Try it online!
Just a single regex substitution.

Marbelous, 26 bytes
..@0
..00
..]]\/
../\
@0../\..

Marbelous is a language based on marble machines

@n (n from 0 to Z) is a portal which teleport the marble to another portal with the same value
00-FF initiate a marble with this value
]] read one byte of input into a parsing marble
\/ is a trash can
/\ create a duplicate passing marble to it's left and right
.. is a noop
marbles going out of the machine from the bottom are implicitly outputed

interpretor

Rockstar, 82 73 66 57 bytes
listen to S
cut S
O's ""
while S
let O be+roll S*2

say O

Try it here (Code will need to be pasted in)
listen to S     :Read input string into variable S
cut S           :Split into an array
O's ""          :Initialise O as an empty string
while S         :While S is not empty
let O be+       :  Append to O
  roll S        :    Pop the first element from S
  *2            :    Duplicate
                :End while loop
say O           :Output O

dotcomma, 48 bytes
[[],][.[[[,],],]][.[,]][,[,[,.[[[,][,]][,.].]]]]

Code: <textarea id="txtCode" type="text" class="textBox" style="height: 200px">[[],][.[[[,],],]][.[,]][,[,[,.[[[,][,]][,.].]]]]</textarea>
Input: <textarea id="txtInput" type="text" class="textBox">Double speak!</textarea>
<input id="btnInterpret" type="button" value="Run" />Output as: <select id="lstOutputAs"><option value="true">String</option><option value="">Number array</option></select>
Result:

Code:
[[],]                   insert end marker (0)
[.[                     while characters left
  [[,],],               copy each character 3 times
]]
[.[,]]                  go to first 0
[,[,[,                  delete copies of 0 and first character
  .[[[,][,]][,.].]      delete every third character until we reach 0 again
]]]

Python 3, 67 64 bytes
t=input()
for i in map(lambda x:x[0]+x[1],zip(t,t)):print(end=i)

Try it online!

print("".join(map("".join,zip(*[input()]*2))))

j="".join;print(j(map(j,zip(*[input()]*2))))

Whispers v1, 38 bytes
> Input
>> L+L
>> Each 2 1
>> Output 3

Try it online!
Squeezed pseudo code:
>> Output ( Input.map( c -> c + c ) )

Explanation:
As usual in Whispers, the last line is executed first by default:
>> Output 3

This line outputs the result of line 3:
>> Each 2 1

Here we expect line 2 to be a function and line 1 to be an array. It returns the array specified in line 1, whose elements were modified by the function in line 2.
Let's look at this array first:
> Input

Takes the first line of the input. So we get an array of characters.
Now line 2:
>> L+L

L is an argument from the Each statement in line 3. Since we are working with strings, L is returned concatenated with itself.
So the squashed pseudo-code is:
>> Output ( Input.map( c -> c + c ) )

Haskell, 18 bytes
f s=s>>= \c->[c,c]

Try it online!

[MashedPotatoes], 315 bytes
synchronized(0.0f){WHILEstd::ignore=`uniq-c`s/nullptr//gWENDgoto++i;(formatt"case__dict__of{_->OUTPUT=void(0)}def$ARGV(--help)usestrictqw/*read-eval*/;endgoto<>;gotoObject;defstd::ignore(--help)guardnullptrend(formatt"procFS{STDERR}{SETLOCAL()import$ARGV;}std::cout<<--help<<std::endl;goto0.0f;goto++i;")goto<>;")}

This is not short, by any means.  But I've wanted to try and use MashedPotatoes for something, since the language is so odd.  So it might be possible to shorten the code,
but it's the sort of language where I'm relieved if I get something to work. :)
It's not available on TIO, so here's a link to the Esolang entry for the language.
https://esolangs.org/wiki/MashedPotatoes
There's a link the GitHub entry with the code on the page.
And there's one caveat about the interpreter...  I submitted a PR to the repo to make it possible to handle EOF when reading character input, and this code relies on that enhancement.  The maintainer merged it today (meaning 4/17/2021) so if you may need to refresh your copy if you pulled it previously.
I think a brief explanation of some language quirks are probably necessary first...  There are 3 registers ^A, ^C, ^E, three stacks 0, 1, 2, two triggers A, B, and three labels 0, 1, 2 available.
The constants STDERR, $[, ~uniq -c~ (where I've used ~ to replace backticks since I cannot figure out how to make backticks work inside backticks) references registers ^A, ^C, ^E respectively the first time they appear in the code.  Then they change to the next register the next time they are used.  Meaning STDERR evaluates to the
value of ^A the first time it appears in the code, to ^C the second time, etc...
Trigger A is referenced by the constants use strict qw/LABEL/;, SETLOCAL LABEL, import LABEL;, CFLAGS=LABEL, \emph{LABEL}, ~cat LABEL~ (again ~ used in place of a backtick here) cyclically.  Meaning the first occurence of trigger A in the code will be
use strict qw/LABEL/;, the second time will be SETLOCAL LABEL, etc...  And LABEL is replaced the target label.
Similarly trigger ^B is references by the constants s/LABEL//g, OUTPUT = LABEL, guard LABEL, lambda: LABEL, """LABEL""", also in the same cyclical manner.
Label 0 is referenced by the symbols 0.0f, ++i, <>, Object cycically.
The cyclical reference names for label 1 are std::ignore, nullptr, __dict__, void(0).
And the label 2 references are $ARGV, *read-eval*, FS, ().
A better description can be found on the Esolangs page for the language.
And next, the code...
synchronized (0.0f) {

This just assign the label 0, the value 1 since the ( is on line 1 of the code.
  WHILE std::ignore = `uniq -c` s/nullptr//g WEND

Increments the value of register ^E.
  goto ++i;

Shifts the values of the registers, effectively ^A -> ^E -> ^C -> ^A
  (format t "

Loops while ^C is greater then 0
    case __dict__  of { _ -> OUTPUT = void(0) }

Reads one character from STDIN into ^A
    def $ARGV(--help) use strict qw/*read-eval*/; end

Pushes the value of ^A to stack 0, since ---help evaluates to 0
    goto <>;
    goto Object;

Shift the registers twice.
    def std::ignore(--help) guard nullptr end

Pop the value of stack 0 into ^A, the result of the the last 4 actions is effectively ^C = ^A
    (format t "

Loop as long as ^C > 0, effectively if not EOF { ... } since EOF is codepoint 0.
      proc FS {STDERR} {

Code block for output operations
        SETLOCAL ()

Print the value of ^A, mapping the codepoint to a character
        import $ARGV;

Repeats the same, meaning print ^A a second time
      }

End of output code block
      std::cout << --help << std::endl;

Set ^A to zero.
      goto 0.0f;
      goto ++i;

Shift the registers twice, effectively sets ^C to 0 to cause the loop to exit
    ")

End of the print loop, which will never run more then once since we explicitly set ^C to 0 to prevent that.
    goto <>;

Shift the registers, sets ^C to the last codepoint read from STDIN, will be 0 on EOF.
  ")

End of the outermost (format loop, will decrement ^C and compare against 0, so if the read got any character the loop will repeat.
}

End of synchronize code block.

Factor + sequences.repeating, 12 bytes
[ 2 repeat ]

Try it online!

Numberwang, 6 bytes
248337

Try it online!

That's Numberwang!

Wang even is this language?

Hexagony, 11 bytes
,)</;(/@>;~

Try it online!
Just some simple control flow on this one, could def be improved.

A0A0, 165 150 142 bytes
A0A0
A0C3G1G1A0
A0I1A6V0P0G6C6A0
A0A1G-3G-3A0
G-3

A0A0
C3G1G1A0C3G1G1A0

A0A1G-3G-3A0
G-3
A0A0
C3G1G1A0C3G1G1A0
G-10A0G-10A0
A0A1G-3G-3A0
G-3

The program consists of three loops right after one another. The first loop does the following:
I1A6V0P0G6C6
I1           ; take character input, store in V0
  A6         ; append this line to the line six below
    V0       ; operand, holds input
      P0     ; prints input
        G6   ; jumps to six lines below
          C6 ; removes all instructions on the six lines below

We duplicate the operand and print instructions a little lower, so we can print it twice. We then jump to there and the last C6 is to get rid of any other instructions that we didn't need afterwards.
The second loop is empty and is constructed from the first loop. The loop is also partially executed so we can enter the loop at the same place each time. This loop will print the character a second time. Because there is a nice G6 instruction inside the copied instructions that will also be executed, we use that as a way to escape from the infinite loop. This is because six lines below is yet another loop.
G-10G1G1
G-10     ; jumps 10 lines up, back to the first loop
    G1   ; no-op
      G1 ; no-op

This is a simple infinite loop (also partially executed) that takes us back to the first loop. It's padded with no-ops, since the loops needs at least three instructions. Because the first loop contains a C6, any redundant instructions in the second loop will be removed once we get back to the first loop.
Edit: Optimized by 15 bytes. I misunderstood the default loop template I make use of in the code. I was under the impression that the amount of G1 and G-3 instructions on line 2 and 4 of the loop resp. needed to match the amount of instructions inside the loop. This is not the case, you only need two of them (although more also work, as long as each line has an equal amount of them). This change removes these extra instructions.
Edit 2: Optimized by 8 bytes. Because of edit one, it turns out that there's actually no minimum of three instructions in the loop. This allows us to drop four instructions (not two, since the loop at the bottom is partially evaluated), totalling eight bytes.

MineFriff, 4 bytes
:oo~

Try it online!
No, I totally didn't forget to add input to MineFriff. You have to supply the string to double speak in the header, which can be generated using this Vyxal snippet.
Explained
:oo~
:    { duplicate the top of the stack }
 oo  { print it twice }
   ~ { back to the start of the line }

Zephyr, 89 bytes
input s
set i to 1
set o to""
while""<s[i...i]
set o to(o+s[i])+s[i]
inc i
repeat
print o

Try it online!
Explanation
Oh. My. Goodness.
I spent 20 minutes convinced this challenge wasn't possible in Zephyr. All the language design choices that I made 11 years ago came back to bite me:

There is no way to get the length of a string (not a design choice, I just didn't implement anything).
The print statement adds a trailing newline by default. Suppressing the trailing newline with ... adds a space instead.
The concatenation operator | also puts a space between the two values.

But a couple of things went right:

String slicing exists, and doesn't throw an error if the indices are out of bounds.
You can concatenate any value to a string using the + operator. In hindsight, I'm not sure why I thought this was a good feature, but there it is.

And so:
input string
set index to 1    # Zephyr uses 1-based indices
set output to ""
# Loop until index is out of bounds, at which point the string slice returns empty string
while "" < string[index...index]
    set output to (output + string[index]) + string[index]
    inc index
repeat
print output

CLC-INTERCAL, 85 bytes.
DO;1<-#1DOCOMEFROM#2DOWRITEIN;1(1)DO:1<-;1SUB#1DDOCOMEFROM':1~:1'~#1(2)DOREADOUT;1+;1

Copy and paste to try it online!
With comments, though I don't know its necessity
DONOTE length of array
DO;1<-#1
DOCOMEFROM#2
DONOTE perform getchar() for a time to store to ;1SUB#1
DOWRITEIN;1
DONOTE EOF: zero; otherwise: at least 65536
(1)DO:1<-;1SUB#1
DONOTE die here
D
DONOTE ':1~:1'~#1: zero if EOF one otherwise
DOCOMEFROM':1~:1'~#1
DONOTE putchar() twice
(2)DOREADOUT;1+;1

Python, 67 bytes
from itertools import*
print(*chain(*[i*2for i in input()]),sep="")

Minim, 73 Bytes (44 w/o Output)
Program is run as follows:
C:\Users\chris> minim -a "Double speak!" -f golf.min

Arrays of values, and subsequently strings, cannot be returned or passed around to statements, and the interpreter uses only index 0 for a 'return/exit value'. Therefore I've opted to just print the modified string to the console.
[0]=L*2+1.[1:]=A.[[0]]=[[0]--/2]._^![0].C=1.[0]=2.$<[[0]++]._^![[0]].C=5.

With whitespace and comments:
;;; Insert string into memory and modify it

[0] = L * 2 + 1.         ; Set index 0 to twice the length of the program arguments plus 1
[1 :] = A.               ; Insert program arguments at index 1
    [[0]] = [[0]-- / 2]. ; Set index of index 0 to half of memory at index of index 0, and decrement index 0
    _^ ![0].             ; Skip the next statement if index 0 is 0
C = 1.                   ; Set program counter to 1

;;; Output modified string (no string/array return)

[0] = 2.        ; Set index 0 to 2.
    $< [[0]++]. ; Print index of index 0 as Unicode, and increment index 0
    _^ ![[0]].  ; Skip the next statement if index of index 0 is 0
C = 5.          ; Set program counter to 5

Without printing it, the program goes down to just 44 bytes.
[0]=L*2+1.[1:]=A.[[0]]=[[0]--/2]._^![0].C=1.

The modified string is now just in memory.
GitHub Repository

Python 3, 31 24 bytes
-7 bytes by returning a list of characters instead of a string
lambda s:[c*2for c in s]

Returns a list of characters instead of a string.
Try it online!

Mascarpone, 12 bytes
[,:..:!]v*:!

Try it online!
Pretty simple.
[      ]v*    Push the following as an operation to the stack.
 ,:..         Input a character and output it twice.
     :!   :!  Duplicate the operation and run it so that it loops.

Python 3, 44 43 41 37 25 24 Bytes
I have refactored it a ton and came to this answer:
print(*[x*2 for x in input()],sep="")
Try it online!
then from there I got to
lambda i:[x*2 for x in i]

The TIO doesn't work properly due to it being a function but here it is anyways: The TIO now works thanks to des54321 for their advice:
Try it online!
Here's my other implementation of this challenge with greatly appreciated help from the comments:
print("".join(map(lambda x:x*2,input())))
Try it online!

End result as of 26/05/2022 thanks to everybody's changes lambda i:[x*2for x in i]
Try it online!
Description
It works by separating the script using pythons map function to grab every character in the inputted string then multiplying them by 2 and joining them back together after it is converted to a map using an empty string then joining every element to it.
Thanks to pxeger for suggesting to remove unnecessary spaces, to Wheat Wizard ♦ for suggesting to remove the quotes from the input, to des54321's advice of using f=\ in the header to fix TIO with lambda functions and Nobody's help detecting the unnecessary space in the lambda.

Welcome to Code Golf, and nice first answer! Be sure to check out our Tips for Golfing in Python page for ways you may be able to golf your code! For example, you can remove the space after the comma.

Welcome to the site! You can also remove the "" from input since it defaults to an empty prompt when nothing is provided.

btw you can make the TIO link for the lambda solution work properly by putting f=\ in the header, like this

Well you can refactor it into lambda i:[x*2for x in i].

@NobodyNeedsNames That isn't a valid output format - char lists are allowed, but to get a result you have to join that by the empty string.

@emanresua Good, then it should be WAIT ARGH how do I type code with an iPhone someone help me…

K (ngn/k), 11 bytes
{,/{x,x}'x}

Try it online!
Quick.
Explanation:
{,/{x,x}'x}       Main program.
        'x        For each character in the string...
   {x,x}          Duplicate the character twice
 ,/               Then join each duplicated character together

GeoGebra, 40 bytes
s="a
InputBox(s
Sum(Zip(S+S,S,Split(s,{"

Input goes in the Input Box.
Just found out about GeoGebra's parentheses/quotation marks/(other stuff I'm missing) auto-complete when pasting in code, really cool.
Try It On GeoGebra!

Alice, 12 9 bytes
/O./
@IZ\

Try it online!
Explanation Flattened
/        Switch to Ordinal mode
 I       Reads a string from the input
  .      Duplicates it
   \/    Does a U turn and switch line
     Z   Zip the two strings
      O  Print it
       @ Bye

MUMPS, 36 bytes
a(s) f %=1:1:$l(s) w $e(s,%),$e(s,%)

Try it online!
Explanation:

a(s) labels this line as a subroutine a with one parameter s.
$l is short for $length and returns the length of a string.
f is short for for. f %=1:1:$l(s) loops from 1 to $l(s) in steps of 1 with the variable % storing the current value.
$e is short for $extract. $e(s,%) gets the character of s at position % (one-indexed).
w is short for write and prints the expression that follows it.

Rattle, 12 bytes
|I=@P[gbb>]`

Try it Online!
Explanation
|              take string as input
 I             split string into characters and store in consecutive memory slots
  =@           set top of stack to the value of the pointer (i.e. length of string)
    P          set pointer to 0
     [....]`   repeat n times where n is the top of the stack
      g        get character in storage at pointer
       bb      add character to print buffer twice
         >     shift pointer right
               [print buffer output implicitly]

C (gcc), 57 bytes (code) + 11 bytes (flags) + N bytes (argv[1])
Note: the flag in question is -Dx=s[1][i]
this code compiles with GCC and Clang
I also had a solution with shorter source code, but including the flags there are more bytes.
main(i,s)char**s;{for(i=0;x^'\0';i++)printf("%c%c",x,x);}

tricks used:
I was able to skip adding int i, char**s by adding the char**s after main is declared, saving 2 bytes. I was also able to set i=0 in the for loop to save a single byte. Using the flag -Dx=s[1][i] saved me 7 bytes.
Try it online!

We don't require counting flags in the byte count anymore.

What's the + N bytes (argv[1])? You don't count input in the bytecount.

@Steffan dang, I didn't know that. I have a much shorter solution then. Also, I did not realize that we did not need to include the byte count on input. I have a question, can't I make my code 1 byte with a flag containing the entire source?

Technically yes, but that's disallowed as a loophole. https://codegolf.meta.stackexchange.com/a/5076/92689

https://codegolf.meta.stackexchange.com/a/14339/92689

@Steffan Follow up question, is my flag -Dx=s[1][i] not allowed then?

It's allowed, but it might be generally more well-received if you just used #define.

49 bytes

Fig, \$\log_{256}(96)\approx\$ 0.823 bytes
Y

See the README to see how to run this
Polyglots with Vyxal and does the exact same thing: interleaving the input with itself.

Raku, 21 bytes
{[~] [Z~] .comb xx 2}

Try it online!
{                   }  : anonymous code block
          .comb        : yields chars of input string
                xx 2   : repeat list of chars
     [  ]              : reduction metaoperator
      Z~               : Z operator and concat operator
                       : Z is a metaoperator here that zips using ~
 [~]                   : concat zipped list of repeated chars

Funnily enough, you can remove the [Z~] simply by capitalising the first x. I also have a regex based answer

lmao that is quite the trick. I like your regex based answer. Lakmatiol in the raku discord came up with {S:g/./$/$//}, which is 13 bytes. I was going to improve mine with it but I will leave it be. Should I continue to use Raku for the language or prefer Perl 6?

Perl 6 was the old name for Raku, so some older answers are mislabelled. Raku is the preferred name these days

That was the impression I was under. Thanks

I was pretty happy with my 16; that 13-byte answer from the Discord is impressive.

Piet + ascii-piet, 18 bytes (3×6=18 codels)
Technically, we can create a trivial 5 codel (4 ops + 4 no-ops) answer that will never terminate.  This non-trivial no-error implementation is a lot more interesting.

Codel size 1:
rfnf Tk??k?Ttilj t

Try visual Piet online! or Try npiet online!
This improves the answer by @gastropner with 2 codels.  Instead of a 5×4 image, this uses a 3×6 image.  If you count the number of bytes using ascii-piet, you will find that the previous answer was 18 bytes as well and this is not an improvement but an alternative.
We use the fact that invalid instructions get ignored and got lucky that the whole program is a cycle, just like the previous answer.  The main loop is a total of 10 operations, which is an improvement of 1 compared to the previous answer.  This improvement was possible by moving the termination point to the right instead of bottom left.  In order, the operations are:
1.  Output the top value on the stack as character,
2.  Pop the top value from the stack (0 for all but the first loop),
3.  Push 1 to the stack,
4.  Use a `not` operation to turn it into 0,
5.  Push the input character to the stack,
6.  Duplicate the input character
      (OR 0 in case there was no input character),
7.  Duplicate it again,
8.  Use a `not` operation to turn the top value into
      a 0 if there was a (non-null) character and
      a 1 if there wasn't,
9.  Exit the loop if the top value from the stack is 1,
10. Output the top value on the stack as character.

I don't think it's possible to remove popping 0 from the stack, because you need the 0 on the stack which requires steps 3 and 4.  If you remove step 2, your program could technically become 9 steps total at the expense of an ever growing stack, however, loops must always use an even number of codels.  With 9 operations you would thus need a 2 codel block to make up for the odd number.  If you could get the program to work in 8 steps, that's probably the minimum as I believe you will necessarily need 8 operations: INC DUP DUP NOT OUTC OUTC DP+/CC+ PUSH.  Using the same DUP and OUTC commands will be very difficult with so little space, but I think that would be the only option for reducing the size.  Lastly, I do think you need the ninth NOT to contrast the sentinel with the input character, because you cannot check for the difference between a successful command and an ignored command without having a different truth value for both.
Note that this also fixes a small bug in the previous answer.  The problem with that code is that the Codel Chooser switches between left and right for each iteration.  This means that half the time, no 1 is added to the stack and then the previous value on the stack is used in the NOT operation.  Then if it reaches the DP+ operation with a 1 (a quarter of the time) and this is the end of the string it will act as if this is the input character and print two <SOH> characters.  This bug only occurs for strings of length +.

str, 2 bytes
do

d = duplicate, o = output. Runs characterwise by default.
Try it online!

Python 3, 39 38 bytes
lambda s:(j:=''.join)(map(j,zip(s,s)))

Try it online!
Explanation:
lambda s:                              # a function which takes a string and...
                            zip(s,s)   # zips it with itself,
                      map(j,        )  # joins each tuple,
         (j:=''.join)(               ) # and joins each string together.

JavaScript (Node.js), 27 bytes
Unsurprisingly not the best JS answer.
Takes array of characters as input since it seems valid for some answers. Output is a string.
s=>s.map(b=>a+=b+b,a="")&&a

Try it online!

><>, 4 bytes
i:oo

Try it online!
Terminates with an error.
Explanation
i    # Input one character from STDIN
 :   # Duplicate it
  oo # Output twice
     # This keeps looping until there is no more input to read

Uiua, 4 bytes
♭⍉⊟.

Try it
Starting with the string "Abc":
couple ⊟ the string with a duplicate . of itself:
[ "Abc"
  "Abc" ]

transpose ⍉ this.
[ "AA"
  "bb"
  "cc" ]

deshape ♭ (flatten) this, yielding the final string:
"AAbbcc"

C (clang), 60 50 bytes
gets(s);while(s[(int)i])putchar(s[(int)(i+=0.5)]);

Try it online!
Saved 10 bytes Thanks to Peter Cordes

This snippet depends on declarations and initializers (like float i = -0.5) outside the block you're counting.  You need to count all the bytes of your code for a whole function or block that can be used on its own without dependencies on other parts of the source code.  e.g. a whole function + any global variables it uses.

Interesting idea, though, to use float increments to half-step.  putchar would be shorter than printf("%c", and also !=0 is implicit in while(s[(int]i]).  I think ISO C guarantees that \0 has integer value 0, and I'm sure that it's guaranteed to be the only "false" character value so a strlen like while(*s++) is a safe.

Congratulations on your first answer! I remember when I first started, it was a bit complicated to figure out what should be counted and what shouldn't be counted (I'm still not sure sometimes). From this meta post, a function is also a valid submission, in which case we can abuse a bunch of things in C to get this 51-byte answer. It's not pretty though

Thanks guys for the comments, still learning so please forgive any mistakes and thanks for the ideas Peter would definitely try implementing them.

Building on @maxb 41 bytes

4, 21 bytes
3.6000180070050050094

Try it online!
Explanation
3.          Start the program
6 00 01     Set memory cell 00 to 1 (BF +)
8 00        Start a loop while memory cell 00 is non-zero
7 00        Feed input to memory cell 00 (BF ,)
5 00 5 00   Print input 2 times ("a" -> "aa")
9           Jump to the corresponding 8

SimpleTemplate, 23 bytes
This answer is for a language I wrote, which was supposed to be for templates but hasn't seen many updates.
This is the basic "split, loop, output twice", but without the splitting.
{@eachargv.0}{@echo_,_}

And now, ungolfed:
{@each argv.0 as char}
    {@echo char, char}
{@/}

And an explanation:

{@each argv.0 as char}
Loops over each value in argv.0, which is the first argument given when calling the render() method.
Due to this, you can pass an array of characters or a simple string, and it will loop through it.
The as char is optional and the default variable name is _.
Whitespace is optional

{@echo char, char}
Outputs char. Twice.
Whitespace is optional

{@/}
Closes the scope of the {@each ... }.
This is optional, as the language was written to keep track of how many scopes were open and automatically closes all at the end.

Pretty simple, right?
You can try it on: http://sandbox.onlinephpfunctions.com/code/d008a116a051df131edf02533182c5305cf8e834
When trying, you can go to line 906 and change the variable between $golfed and $ungolfed to try both versions.

Forget, 61 55 bytes
I created this language when I was bored one day. I released it the same day as this challenge was posted. I can guarantee this was not designed specifically for this challenge.
in;cleanse;out;out;pop;hasin;in;cleanse;out;out;pop;end

-6 bytes by terminating on EOF
There's no TIO (yet). The interpreter is available here There's a TIO now
Explanation:
in - reads a character from standard input and pushes a pointer to the stack
cleanse - unpoisons the pointer on top of the stack
out - prints the value stored at the address on top of the stack as a character
out - see above
pop - removes the value from the stack to avoid memory leaks
hasin - while characters are available on standard input...
(the body of the loop is the same as before it)
end marks the end of the loop
The only way this program can error is if the interpreter forgets the value stored at the address on the stack and the program attempts to use it.

Ruby, 16 bytes
gsub /./m,'\0\0'

Requires -p.
Try it online!
Alternatively:
gsub(/./m){$&*2}

Try it online!

Without a flag its: ->s{s.gsub(/./m){$&*2}}

Python 2, 31 bytes
Realised I was beaten to it already.
lambda s:''.join(c*2for c in s)

SNOBOL4 (CSNOBOL4), 69 bytes
	I =INPUT
S	I LEN(1) . X REM . I	:F(O)
	O =O X X	:(S)
O	OUTPUT =O
END

Try it online!
Prints with a single trailing newline.

kavod, 16 bytes
*>1+8?99.1-#<#0.

Try it online!
I picked up a random tarpit and decided this would be a nice challenge to solve
Explanation:
*     Take a byte of input and push to stack
>     Push to the register stack without popping from normal stack
1+    Add one to the input
8?    Go to the eighth character in the program if the top of the stack is nonzero (not EOF)
99.   Go to the 99th character in the program (terminating the program). This will be skipped over if input is not EOF
1-    Decrement TOS
#     Print with popping
<#    Get input back from register stack and print it
0.    Go back to the start of the program.

Charcoal, 5 bytes
⭆Ｓ⁺ιι

Try it online! Link is to verbose version of code. Explanation:
 Ｓ      Input string
⭆       Map over characters and join
   ι    Current character
  ⁺     Plus
    ι   Current character
        Implicitly print

PHP, 74 bytes
function doubleSpeaker ($s) {
    return preg_replace('/(.)/', '$1$1', $s);
}

Try it online!

Welcome to CGCC! The winning criteria for this challenge is [tag:code-golf] which means submissions should attempt to have the smallest amount of bytes. This submission seems to have a lot of excess whitespace and unnecessarily long variable names. Additionally, you should add the language name and score to the header of your submission.

Just in a few seconds, your solution was lowered to 41 bytes: Try it online! Nice RegEx idea by the way.

Capturing is pointless. Try it online!

Same idea as in my Lua answer btw, just implemented in PHP.

Using @manatwork's update and $argn: Try it online! 36 bytes.

3var, 10 bytes
k'>|[PP'>]

Try it online！

Aceto: 5 bytes
,dppO

Doesn't work on TIO, because it hangs indefinitely. Buffering might prevent you from seeing the result, run with -F to immediately flush all output.

Brain-Flak, 26 bytes
{(({}<>))<>}<>{({}<>)<>}<>

Pretty simple, and my first Brain-Flak answer :D
(Note: this requires the -a and -ac flags for ascii I/O)
How it works
{  Begins a loop that will run for every character of input
(({}<>))   Pops the top element of the stack and pushes two copies of it to the second stack
<>  Go back to the first stack
}   End loop
<>   Go to the second stack
{({}<>)<>}   Reverse the second stack and puts it onto the first
<>  Go to the first stack do it outputs it

Try it Online!

Q'Nial7, 28 bytes
d is OP N{link cols mix N N}

result:
     d 'Double Speak!'
DDoouubbllee  SSppeeaakk!!

Explanation, using detailed picture mode:
     set "decor                 %turn on decoration of atoms and empty arrays,
                                %gives a picture that distinguishes all atoms
"decor
     set "diagram
"diagram                        %set default display mode to diagram,
                                %give full boxed picture of results
     N:='Double Speak!'         %define string N
+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+
     mix N N                    %nesting restructuring: create table of items
                                %from list of items, the list being N N
+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`o|`u|`b|`l|`e|` |`S|`p|`e|`a|`k|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+
     cols mix N N               %nesting restructuring: list of columns
                                %of the table
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------
|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+
||`D|`D|||`o|`o|||`u|`u|||`b|`b|||`l|`l|||`e|`e|||` |` |||`S|`S|||`p|`p|||`e|`e|
|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+|+--+--+
+-------+-------+-------+-------+-------+-------+-------+-------+-------+-------

+-------+-------+-------+
|+--+--+|+--+--+|+--+--+|
||`a|`a|||`k|`k|||`!|`!||
|+--+--+|+--+--+|+--+--+|
+-------+-------+-------+
     link cols mix N N          %construction op: items of the first item of N
                                %are followed by the items of the second item of N, etc.
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+
|`D|`D|`o|`o|`u|`u|`b|`b|`l|`l|`e|`e|` |` |`S|`S|`p|`p|`e|`e|`a|`a|`k|`k|`!|`!|
+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+--+

C#, 104 bytes
public class P{public static void Main(string[]a){foreach(char c in a[0])System.Console.Write(c+""+c);}}

Try Online

Go, 110 bytes
func main(){for j:=0;j<len(os.Args[1]);j++{fmt.Printf("%c%c",os.Args[1][j],os.Args[1][j])};fmt.Printf("\n");}

Try It on Jdoodle!

Clojure, 25 bytes
(fn[s](apply str(map #(str % %)s)))

[awk], 24 bytes
awk '$0=gensub(/./,"&&","g")' <<< "Double speak"

Try it online!

I guess you accidentally pasted an older code version since you still debugged it. That would explain that \n.

Yes, you are right. Thanks for pointing me to this.

You could shorten it by learning from Leo Tenenbaum's sed solution and avoid using a capture group: $0=gensub(/./,"&&","g").

Thanks @manatwork. I shortened it.

Super late to the party... but I think gsub(".","&&") will work too. Meaning just that, the assignment to $0 is implicit.

@cnamejj will check it out.

FWIW, I'm using GNU AWK if that makes the difference.

Yeah that's a GNU extension.

[sed], 13 bytes
sed 's/\(.\)/&&/g'  <<< "Double speak"

Try it online!

Please use a properly formatted heading line for your answer so the leaderboard script can parse it. 2) The quotes around the code are necessary only when specified in command line due to the shell's own parsing rules, they not need to appear in the answer and even less to get counted. 3) As possible please add TIO links to your answers so people can try them out easier and see how input is supposed to get passed to the code.

Just as information (its existence doesn't invalidate your solution), Leo Tenenbaum's sed solution is shorter. ☹

@manatwork: Oh sorry, I visually "grepped" through the StackExchange posts, but didn't see sed.

Yes, capture group is not needed, so @LeoTenenBaums's solution is better.

Binary Lambda Calculus, 10 bytes
8446 0016 c25b 3fdf 9ade

This program was on this page and was known as a ``stuttering'' program.

GolfScript, 9 bytes
Great if this hasn't been posted yet.
[{.}/]''+

Try it online!

@, 8 bytes
¤ōōč

Explanation
¤    Forever
   č Read a character
 ōō  Output twice

Pyth, 5 bytes
sm*2d
s      Concatenate
  *2d  lambda d: d*2
 m     Mapped over
     Q Input (implicit

Try it online!

3 byter here, but theres a 2 byte solution for pyth here

Add++, -i 8 bytes
L,dzbFBJ

Try it online!
This creates a lambda (L) that:

duplicates the input string (d)
zips the two strings together (z)
flattens that list (bF)
and joins it together (BJ)

Finally, the -i flag auto executes the lambda.

Pip, 4 bytes
aWVa

Try it online!
A pip answer without loops.

Canvas, 3 bytes
２１＊

Try it here!

Python 3, 31 bytes
lambda s:"".join(c*2for c in s)

-4 bytes thank you to Redwolf Programs for suggesting lambda method.
Try it online!

Hi! Taking input by assuming a variable contains it isn't allowed, but you can use a lambda (and if you do, there's no need for a print!).

Lua, 31 bytes
print(((...):gsub(".","%1%1")))

Try it online!
Explanation
... is the multi-return formatted version of the arg table. We encase it in parentheses here so that it only returns one value (the first).
gsub() is the global substitution function, it takes a pattern and returns a string with every instance of it replaced according to the second parameter.
"." is a pattern matching any single character.
"%1%1" is a pattern which is used as the second parameter to gsub. %1 means the first case, which is the whole match in this instance, so it repeated the entire match twice.

VBScript, 88 bytes
s=wscript.arguments(0):k=""
for i=0 to len(s)-1
n=mid(s,i+1,1)
k=k&n&n&" "
next
msgbox k

First argument as the string

V (vim), 5 bytes
òylpl

Try it online!
òylpl
ò       " loop until error
 yl     " yank character under cursor
   p    " paste it
    l   " move right

Alt:
V (vim), 5 bytes
òälll

Try it online!
ä{motion} is a synonym for y{motion}P which is almost what we want but pastes backwards rather than forwards, so we need another l here, tying the vim-ier first solution.
Equivalent vim version:
Vim, 11 bytes
qqylpl@qq@q

Try it online!

Another 5 byte V: Ó./&&. Ironically, this can be ported perfectly to vim and also ties your vim solution haha: :s/./&&/g<cr>

Duocentehexaquinquagesimal, 3 bytes
6÷V

Try it online!

Unlambda, 11 bytes
``ci`c`|`@|

Try it online!
On its own, `|`@| is an identity function with a side effect of reading a char from the input and printing it twice. `ci is a call-with-cc trickery that ends up applying its argument to itself, hence `c`|`@| is the same with the above-mentioned side effect; all in all, this will set up a loop.
(The solution is memory inefficient, as each iteration will create a new continuation, hence the space used will be linear or quadratic in the length of the input, depending on the implementation. This can be fixed at the expense of adding two more characters: ``ci`d`c`|`@|.)

Ly, 7 bytes
ir[:oo]

Try it online!
Oddly enough, this turned out to be similar to the Brainfuck answer someone else posted...
i        - reads in a line, adds each character to the stack as a codepoint
 r       - reverse the stack
  [   ]  - a "loop while stack not empty" construct
   :     - duplicate the top of the stack
    o    - pop the top of the stack and print codepoint as char
      o  - again...

Pxem, filename: 17 bytes.
\001 is such a byte of binary.
.w.o.o.i.c.c\001.+.a

How it works
Since this program is simple, here is verbose explaination.
XX.z
# while stack is empty or popped value is not zero; do
# NOTE stack is initially empty
.a.wXX.z
  # if not empty; then pop to output its character; fi
  # if not empty; then pop to output its character; fi
  .a.o.oXX.z
  # getchar and push its codepoint value
  # NOTE EOF is -1
  .a.iXX.z
  # if not empty; then duplicate; fi
  # if not empty; then duplicate; fi
  .a.c.cXX.z
  # push one
  # if stack has two or more items; then pop twice and push their sum; fi
  .a\001.+XX.z
# done
# NOTE reaching to end of filename implicitily terminates the program
.a.a

Try it online!

<>^v, 29 bytes
.—""?§0 27 0«0 82!=0_~~?(___|

Explanation
.—""?§0 27 0«0 82!=0_~~?(___|

.                             Input string, push to stack
 —                            (not a minus) Reverse the string
  ""                          Push empty string to stack
    ?                         Swap top two elements
     §                        Split top of stack (now the user input) with second element of stack (`""`)
      0                       Push 0
        27                    Push 27
           0                  Push 0
            «                 Goto ; redirects program to the `|`
                            | Reverses instruction pointer direction, now going left
                           _  Pop stack
                          _   Pop stack (again)
                         _    For the third time, pop the stack
                        )     Decrement top of stack
                       ?      Swap top two elements
                      ~       Print top of stack without newline
                     ~        Print top of stack without newline (again, for the double character)
                    _         Pop stack
                   0          Push 0
                  =           Execute next instruction only if top two elements of the stack are equal
                 !            Exit, executed only if the top two elements of the stack are equal
               82             Push 28 (pointer is going left, so literal 82 -> value 28
             0                Push 0
            «                 Goto _
                          _   (Loop goes on, go back to the first "Pop stack")

It first reverses the string, then splits it into characters. Then it goes into a loop reverse-iterating the characters and printing them twice, popping them at the same time, each time decrementing the "characters left" counter which is at the top of the stack, and exits when "characters left" is 0.
Mostly inspired by this other answer I made
run online (>  is the prompt, cannot remove it)

SM83, 8 bytes
Input string pointer in de, output string pointer in hl
1A 13 23 B7 C8 23 18 F8

dbl:
    ld a,(de)               // 1A       read
    inc de                  // 13       and increment
    ld (hl+),a              // 23       write and increment
    or a                    // B7       cheap test for zero
    ret z                   // C8       return if zero
    ld (hl+),a              // 23       write and increment again
    jr dbl                  // 18 F8    loop

Arduino, 113 bytes
#define S Serial
int c;void setup(){S.begin(300);}void loop(){if(S.available()){S.write(c=S.read());S.write(c);}}

Pretty simple. If there are unread characters from the serial input, write them twice.
Explanation:
#define S Serial /* This abbreviation is worth it if it's used more than twice */

int c;

void setup() {
  S.begin(300); // begin serial communications
}

void loop() {
  if (S.available()) { // if there are bytes to be read
    S.write(
      c = S.read() // read, store, and write it
    );
    S.write(c); // write the stored value
  }
}

Z80, 10 bytes
Input in port ii, output in port oo.
DB ii D3 oo B7 C8 D3 oo
18 F6

Disassembly:
f:
    in a,(ii)
    out (oo),a
    or a
    ret z
    out (oo),a
    jr f

Python, 31 bytes
lambda s:"".join(i*2for i in s)

Gives out an actual string instead of a list of characters.
Try it online!

Hey there, welcome to Code Golf! Unfortunately, someone else came up with this method independently to you: https://codegolf.stackexchange.com/a/250051. Still, nice answer!

Knight (v2.0-alpha), 22 bytes
;=sP W;O+*[s 2'\'=s]sN

Try it online!

Raku, 16 bytes
{[~] .comb Xx 2}

Try it online!
Since the task expressly asked for a function, we're counting the curly braces that turn this expression into one; without them, it will just operate on the current topic $_, so depending on the surrounding code you don't necessarily need them.
~ is the string concatenation operator. Wrapping [...] around it changes it from an infix operator to a prefix function, so everything after it will be joined together into one big string at the end.
.method with no explicit invocant calls the method on the current topic, which here is the unnamed argument to the function. The .comb method splits a string into a sequence of characters (really one-character strings).
str x num repeats the string the given number of times.
X<operator> performs an outer join of its operands and applies the given operator to each pair of items in the result. In this case the right operand is the scalar 2, which just gets paired up with each element in the sequence on the left. So l Xx 2 could also be written, albeit with more bytes, as l »x»2 or l.map: *x 2.
All of the whitespace in the solution is required, unfortunately.

Scratch, 122 bytes
define(s
set[i v]to(1
set[r v]to(
repeat(length of(s
set[r v]to(join(r)(join(letter(i)of(s))(letter(i)of(s
change[i v]by(1

Outputs by modifying a global variable, r, which is automatically displayed (Consensus).
Try it on Scratch

Thunno J, \$ 3 \log_{256}(96) \approx \$ 2.47 bytes
e2*

Attempt This Online!
e is map, and 2* doubles. The J flag joins the resulting list.
Note: eZI and .ZI would also work for the same bytecount.

Thunno 2, 1 byte
I

Attempt This Online! Interleave the (implicit) input string with itself.
Alternatives with J flag:

Z: Zip the (implicit) input string with itself, and join.

€D: Duplicate each character in the (implicit) input string in place, and join.

Was this language written for this challenge?

@AJFaraday no, it's a golfing language I created a few months ago. You can see all the commands here.

X86_64/Linux Machine Code,  27  25 Bytes
Try it online!
Usage:
$> gcc -Wl,-Tbss=0x80000000 -s -static -nostartfiles -nodefaultlibs -nostdlib -Wl,--build-id=none to-double-speak.S -o to-double-speak
$> echo -n "<input>" | ./to-double-speak

Program reads input from stdin (it is sensitive to the exact byte count of input, i.e stray spaces/new lines will change result).
Output is printed to STDOUT
Notes:

-4 more bytes without EXIT_CLEANLY defined (it will segfault to exit). This makes the minimum size 21 Bytes.
The 25-byte size assumes the above compile command which sets the BSS address at an ideal value. With generic compile commands (no linker inputs), its 27-bytes.

Program:
/* Uncomment below if BSS was setup at 2^20. */
/* #define IDEAL_BSS.  */

/* Comment out to save 4 bytes (with segfault to exit).  */
#define EXIT_CLEANLY
    .global _start
    .text
_start:
    /* Incoming registers are zero.  */
    decl    %edx
#ifdef IDEAL_BSS
    btsl    %edx, %esi
#else
    movl    $G_mem, %esi
#endif
    /* eax == 0 == SYS_read.  */
    /* edi == 0 == STDIN.  */
    syscall
    /* Store length in ebp.  */
    xchgl   %eax, %ebp
    negl    %edx
loop:
    /* Setup SYS_write.  */
    movb    $1, %al
    /* SYS_write == 1 == STDOUT.  */
    movl    %eax, %edi
    syscall
    /* Assuming no IO error, we will have successfully written 1
       byte so return (eax) will be 1 again ready for second
       syscall.  */
    syscall
    /* Increment esi.  */
    lodsb
    /* Loop through all bytes.  */
    decl    %ebp
    jnz loop
#ifdef EXIT_CLEANLY
    movb    $60, %al
    syscall
#endif
    .section .bss
G_mem:  .space(4096 * 8)

Example/Tests:
$> for x in "This is double speak" "Hello World" "AaBbCcDdEeFf"; do echo -n "${x} -> "; echo ${x} | ./to-double-speak; done
This is double speak -> TThhiiss  iiss  ddoouubbllee  ssppeeaakk

Hello World -> HHeelllloo  WWoorrlldd

AaBbCcDdEeFf -> AAaaBBbbCCccDDddEEeeFFff
```

Swift 5.9, 40 bytes
let f={String(($0+"").flatMap{[$0,$0]})}

source: Stack Exchange

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

sort: votes