[Question]
  [
As is [well known](https://es.pinterest.com/giddyupingo/chuck-norris-counted-to-infinity-twice/),
> 
> Chuck Norris counted to infinity. Twice
> 
> 
> 
[Besides](https://9gag.com/gag/avnxB3X/chuck-norris-has-counted-to-infinity-backwards),
> 
> Chuck Norris can count to infinity backwards.
> 
> 
> 
Also, although perhaps less known, Chuck Norris can [speak a little Spanish](https://www.youtube.com/watch?v=rkL8uaZckjc&feature=youtu.be&t=32) in addition to English.
# The challenge
Write a program (or function) that can be run in two different languages. In one language the program should output the sequence
```
1, 1, 2, 2, 3, 3, 4, 4, ...
```
and in the other language it should produce the sequence (including leading zeros)
```
1, 2, ..., 9, 01, 11, 21, 31, ..., 89, 99, 001, 101, 201, ...
```
# Rules
* [Programs or functions](http://meta.codegolf.stackexchange.com/a/2422/36398) are allowed, in any [programming language](http://meta.codegolf.stackexchange.com/a/2073/36398). [Standard loopholes](http://meta.codegolf.stackexchange.com/questions/1061/loopholes-that-are-forbidden-by-default) are forbidden.
* Different versions of the same language (such as Python 2/3) don't count as different languages. Related languages (such as C/C++ or Matlab/Octave) do count as different.
* No input will be taken.
* The program should continue to output terms of the sequence until stopped by the user. Since the program will not stop by itself, output cannot be produced at the end. It must be produced while the program runs, either continuously or in batches.
* Output can use STDOUT or equivalent, or can be displayed in a graphic window. Any non-numeric separator between sequence terms is allowed, as long as each term can be clearly distinguished from its neighbouring terms. It is also acceptable if the screen is cleared between terms.
* Either sequence can start at `0` instead of `1`. In that case, in the "twice" sequence the `0` should be repeated, just like the other numbers.
* Leading zeros are significant in the "backwards" sequence. For example, the tenth term is `01`; neither `1` nor `001` are acceptable.
* If the two languages use different character encodings, the program is defined by its *bytes*, not its characters. That is, the bytes should be the same in the two languages.
* Shortest code in bytes wins.
  
[Answer]
# [Python 2](https://docs.python.org/2/)/[C (clang)](http://clang.llvm.org/), ~~109~~ ~~107~~ ~~100~~ ~~84~~ ~~95~~ ~~88~~ ~~89~~ ~~88~~ ~~87~~ 84 bytes
```
i=0;
#/*
while 1:i+=1L;print`i`[::-1]
'''*/
a(){for(;;)printf("%i %1$i ",++i);}//'''
```
Python: [Try it online!](https://tio.run/##K6gsycjPM/r/P9PWwJpLWV@LqzwjMydVwdAqU9vW0Me6oCgzryQhMyHaykrXMJZLXV1dS58rUUOzOi2/SMPaWhMsn6ahpJqpoGqokqmgpKOtnalpXauvD1T6/z8A)
C: [Try it online!](https://tio.run/##S9ZNzknMS///P9PWwJpLWV@LqzwjMydVwdAqU9vW0Me6oCgzryQhMyHaykrXMJZLXV1dS58rUUOzOi2/SMPaWhMsn6ahpJqpoGqokqmgpKOtnalpXauvD1T6HyinkJuYmQdUD9JkzVX7HwA "C (clang) – Try It Online")
The L in the Python code is part of the delimiter.
**Explanation:**
In the C code, It first sets i to 0. Then, it starts a comment (`#` is valid code in C for `#include` statements) where the Python code goes. At the end of the comment, it defines a function that forever increments a variable and prints it twice, space-delimited. It then begins a comment.
In the Python code, `i=0;` sets i to zero. Python ignores the next line because `#` starts a single-line comment. It then forever increments it and turns it into a long a number and prints its reversed string representation. The 'L' from the long is part of the delimiter. After that, it starts a multi-line string to comment the C code, that ends later.
 
-2 bytes thanks to @LuisMendo. -7 bytes thanks to @ZacharyT. -6 more bytes thanks to @ZacharyT. +11 bytes to fix a bug thanks to @mbomb007. -7 bytes thanks to @Doorknob. +1 byte to fix a bug thanks to @Doorknob. -1 byte thanks to @yoann. -1 more byte thanks to @yoann. -3 bytes thanks to @Cyoce.
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E) / [Jelly](https://github.com/DennisMitchell/jelly), ~~14~~ 13 bytes
-1 byte thanks to Adnan (avoid triplicate with non-popping print)
Raw bytes (hexadecimal):
```
31 5b 3d 3d 3e 5d fc 06 b6 3b 87 08 15
```
In [05AB1E](https://github.com/Adriandmen/05AB1E)'s [code-page](https://github.com/Adriandmen/05AB1E/blob/master/docs/code-page.md):
```
1[==>]üε¶;‡ηΩ
```
**[Try it online!](https://tio.run/##AR4A4f8wNWFiMWX//zFbPT0@XcO8zrXCtjvigKHOt86p//8 "05AB1E – Try It Online")**
In [Jelly](https://github.com/DennisMitchell/jelly)'s [code-page](https://github.com/DennisMitchell/jelly/wiki/Code-page):
```
1[==>]‘©Ṛ;⁷®ß
```
**[Try it online!](https://tio.run/##AR8A4P9qZWxsef//MVs9PT5d4oCYwqnhuZo74oG3wq7Dn/// "Jelly – Try It Online")**
### How?
The [05AB1E](https://github.com/Adriandmen/05AB1E) program prints the double count with each entry separated by newlines:
```
1[==>]üε¶;‡ηΩ
1             - push 1 onto the stack
 [            - start infinite loop:
  =           - print top of stack
   =          - print top of stack
    >         -   increment the top of the stack (pop(1), x+=1, push)
     ]        - end the infinite loop
      üε¶;‡ηΩ - this code is never executed nor is it parsed
```
The [Jelly](https://github.com/DennisMitchell/jelly) program prints the reversed count with each entry separated by newlines.
The parser will treat a valid literal between `[` and `]` as the enclosed literal, otherwise these bytes are undefined tokens and as such become equivalent to tokens separating the code into lines. `==>` does not parse as a literal, so the code is effectively:
```
1 - link 1 (not executed but parsed)
1 - literal 1
==> - link 2 (not executed but parsed)
=   - left equals right? (vectorises)
 =  - left equals right? (vectorises)
  > - is greater than the right argument? (vectorises)
‘©Ṛ;⁷®ß - Main link: no arguments
‘       - increment (implicit 0 on left increments to 1 on the first pass)
 ©      - copy the result to the register and yield it
  Ṛ     - reverse, this has an implicit decimal list build, e.g. 142 -> [2,4,1]
    ⁷   - a newline character
   ;    - concatenate, e.g. [2,4,1] -> [2,4,1,'\n']
     ®  - recall the number from the register, e.g. 142
        - The chain has reduced to one item of arity 0, causing a pre-evaluation print:
        -     ...and since the list contains a character it gets smashed together
        -     e.g. [2,4,1,'\n'] prints 241 followed by a newline character
      ß - call this link with the same arity, e.g. as a monad with left = 142
```
[Answer]
## Jelly/Pyth, 15 bytes
```
.V1_`b;"1üÉÉ$
```
Unprintables are mangled by the SE software, so here's a hexdump:
```
00000000: 2e56 315f 6062 3b22 7f31 fcc9 c924 0b    .V1_`b;".1...$.
```
Run with `jelly f file` and `pyth file` respectively.
### Explanation
First comes the Pyth part. `.V` runs an infinite loop over the incrementing sequence starting from its input, which is here `1`. Then we reverse (`_`) the stringified (```) loop index (`b`) and implicitly output it. The `;` is there to end the loop, and the `"` is necessary to treat the rest of the program as a string literal so that the parser doesn't choke on it.
The Jelly part will be explained by first translating the remainder of the program from the Jelly codepage:
```
¶1‘ṄṄ$¿
```
The `¶` acts as a line feed, effectively ignoring the first part of the program by making it a link that is never called. Then we start at `1` and run a while loop (`¿`) that uses `ṄṄ$` (print twice) as its condition, and increments (`‘`) the value as the loop body.
---
Incidentally, replacing the Pyth part with `1[DR,>]` *would* create a valid Jelly/05AB1E submission in 14 bytes, but the current interpeter contains [a bug](https://github.com/Adriandmen/05AB1E/pull/84) that prevents this.
[Answer]
## Perl/JavaScript, 87 bytes
```
s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}
```
### Perl
```
s/0;print/console.log;m/s;$_=s/s/s/m;while(++$_){print((/s,$_+`
`+$_||/&&reverse.$/))}
```
A mechanism I've used a lot in JS/Perl polyglots is to abuse the fact that substitution can accept pretty much any delimiter, using `=` means I can use the initial pointless substitutions (first replacing `0;print` with `console.log;m` with a flag of `/s` in `$_`, which is currently `undef`), then setting `$_` to the result of replacing `s` with `s` in multiline mode (`/m`), which is `0`. Now `$_` is `0` and I start the `while` loop, this then increments `$_`. Next I call `print`, passing in a regular expression that matches (due to `||` at the end which matches an empty string) and use the `&&` operator to then send the reverse of `$_` concatenated with a newline (`$/` is pre-initialised to `"\n"`). This counts to infinity backwards.
### JavaScript
```
s=0;print=console.log;m=s;$_=s=s=s=m;while(++$_){print((m/s,$_+`
`+$_||/&&reverse.$/))}
```
Lots of variable assignments here, masked in the Perl `s///` calls. I set up variables `s` and `m` as `0`, alias `console.log` to `print`, run some pointless division, set `$_` to `0` and begin the `while` loop incrementing `$_`, call `print` passing in `0` (`m/s`, this starts the call to `m` in Perl, but is treated as standard division in JS) and our target string (`$_+"\n"+$_`) via the comma operator, which returns the last item in the list. I avoid the last piece of Perl code (`&&reverse.$/`) because `$_+"\n"+$_` will be truthy and so I can use `||` to produce a `RegExp` object containing the end of the Perl code which is never evaluated.
Tested using Perl 5 and Node 6.
[Answer]
# NodeJS / PHP, ~~131~~ 106 bytes
*-25 bytes thanks to @Titus*
```
<!--
printf=(_,i)=>process.stdout.write(i+i),strrev=i=>i+" "//--><?
for($i=0;;)printf("%s ",strrev($i++));
```
Using NodeJS instead of browser JS for better output formatting and better infinite loop handling.
[Try the JavaScript online](https://tio.run/##LcxBCoMwEEDRvaewoYWEONp9nHiUIhphujBhZrTHT4V2/R//PZ@zLExFYc9rqnW8ATSFadcN7asjh7FwXpJIL7rmQ/sPkyZLnlwnypxOJIzkTWuGASCOU7NltnfCZwjud7LmIa358yt571yo9Qs)  
[Try the PHP online](https://tio.run/##LczBDoIwDIDhO0@BCyZrxsD76HwUDzpCL6xpCz7@NNHzn@/njVtbLjF2LLTbiv4xEmBmqc@iOqm96mHTW8iKp0AwqomUEwkzBde7eY4xL3feuFur@IHwlhL8Zt5dtXd/8U0hAKTWPg)
Note that the TIO output is cut off after 128KB.
[Answer]
# [V](https://github.com/DJMcMayhem/V)/[Brain-flak Classic](https://github.com/DJMcMayhem/Brain-Flak), ~~27~~, 26 bytes
```
(()){[[({}())[]]]}é1òÙæ_æ
```
Hexdump:
```
00000000: 2828 2929 7b5b 5b28 7b7d 2829 295b 5d5d  (()){[[({}())[]]
00000010: 5d7d e931 f2d9 e65f 01e6                 ]}.1..._..
```
[Try it online! in V](https://tio.run/##K/v/X0NDU7M6OlqjuhbIiI6Nja09vNLwcMPhjYdnHl4Wz3h42f///40MDAA) (modified slightly so that it will terminate so you can see the output. On TIO, V only outputs if the program terminates)
[Try it online! in Brain-flak Classic](https://tio.run/##SypKzMzTTctJzP7/X0NDU7M6OlqjuhbIiI6Nja09vNLw8KbDMw8vi2c8vOz///@6ujmJeemliemptsk5icXFmckA)
This isn't the most interesting of polyglots, since the V code has no effect on brain-flak classic, and vice-versa, however it's really fun to use both of my own languages on a challenge, and the two solutions are pretty interesting on their own.
V Explanation:
```
é1              " Insert a '1'
  ò             "   Recursively:
   Ù            "   Duplicate this number
    æ_          "   Flip this line
      <C-a>     "   Increment the number on this line
           æ    "   Flip it back (the '_' is implicit because it's at the end of the program)
```
BFC explanation:
```
#Push a one onto the main stack
(())
#Forever:
{
  #Print twice:
  [[
    #Increment the top of the stack.
    #Evaluates to *i + 1*
    ({}())
    #Minus one
    []
  ]]
#Endwhile
}
```
[Answer]
# Retina / Python 2, 61 bytes
```
#{*M`
#*M`
"""
}`$
1
""";i=1
while 1:print str(i)[::-1];i+=1
```
[**Retina**](https://tio.run/##K0otycxL/P9fuVrLN4FLGUQoKSlxcdUmqHAZgpjWmbaGXOUZmTmpCoZWBUWZeSUKxSVFGpma0VZWuoax1pnatob//wMA) | [**Python 2**](https://tio.run/##K6gsycjPM/r/X7layzeBSxlEKCkpcXHVJqhwGYKY1pm2hlzlGZk5qQqGVgVFmXklCsUlRRqZmtFWVrqGsdaZ2raG//8DAA)
[Answer]
# [R](https://www.r-project.org/)/[Octave](https://www.gnu.org/software/octave/), ~~83~~ ~~80~~ ~~78~~ 71 bytes
*-3 bytes thanks to Luis Mendo*
```
i=0;
while(1)
#{
print(c(i<-i+1,i))
#}
disp(flip(num2str(i)))
i+=1;
end
```
`#{ }#` is an Octave block comment and `#` just so happens to be the comment for R. The R interpreter only sees the next line as the body of the `while` loop, and the Octave interpreter skips right ahead to the Octave code
The R part prints out pairs of numbers starting at 1, and the Octave portion prints out the backwards numbers starting at 0.
I fully expect to be outgolfed (even by the same combination of languages); I've just been writing so much Matlab and R code recently that I figured I'd give it a shot.
[Try it online!](https://tio.run/##DclBCoAgEAXQ/VyjzYgF2dY8TJjRBzNRq0V0dnP73mnLcrtaYUZNzw7vWAnqXooJobBlzAOk6iGafrQiR948IofrmHJJ3EIQpFGaXFhr/QE "Octave – Try It Online") - Octave link
[Answer]
# Ruby / Python2: ~~68~~ 64 bytes
```
i=0
"#{loop{p i+=1,i}}"
exec('while 1:print str(i)[::-1];i+=1')
```
### Ruby perspective
simple init of variable:
```
i = 0
```
`"#{}"` is syntax for string interpolation.
I use it to exec expression instead.
```
"#{loop{p i+=1,i}}"
```
`p` is a shorthand for `puts`. `loop` creates an infinite loop.
Next there is the `exec` thing, but it never gets evaluated, as the infinite loop is by definition infinite. Needed `exec` not to yield syntax error with Python code.
### Python perspective
From perspective of Python, there is a common `i=0`. Next, Python has different syntax for string interpolation, so this line is simply discarded. Next there is an infinite loop similar to what others posted.
[Answer]
## Bash / [Check](https://github.com/ScratchMan544/check-lang), ~~50~~ 28 bytes
Thanks to @Doorknob for saving a bunch of bytes by switching from Python to Bash
```
#>
#v
 #p<p<)#
seq 1 inf|rev
```
### To Bash:
```
#>
#v
 #p<p<)#
```
These are just some comments, which are ignored.
```
seq 1 inf|rev
```
Start a sequence going from 1 to infinity, then pipe the result to `rev`.
### To Check:
```
#>
```
This immediately switches into 2D mode, going right. `>` directs the IP right, which has no effect. It wraps around to the beginning of the line and hits `#` again, which switches out of 2D mode. It then hits `>` in 1D mode, which pushes 0 to the stack. Because it is in 1D mode, the IP wraps to the next line.
```
#v
```
`#` switches the IP into 2D mode again and `v` directs it downwards.
```
 #p<p<)#
```
The first `#` switches back to 1D mode again. `p` outputs the TOS as a number (but does not pop it), and then `<` prints a newline. This is done twice, and then the number is incremented with `)`. `#` switches to 2D mode again, so the IP wraps to the beginning of the line, hits `#` to switch to 1D mode, etc.
[Answer]
# CJam / ><>, ~~27~~ 23 bytes
```
"la,:naonao
"1{_sW%n)}h
```
## To CJam:
[Try it online!](https://tio.run/##S85KzP3/XyknUccqLzEfiLiUDKvji8NV8zRrM/7/BwA "CJam – Try It Online") - note that you have to wait until the 60 second limit to see the output, but it works offline.
```
"la,:naonao
"
```
This defines a multi-line string literal that is never used.
```
 1{_sW%n)}h
```
The second line goes like this:
```
1     e# Push 1:               | 1 
{     e# Forever:              | 1
  _   e#   Duplicate:          | 1 1
  s   e#   Convert to string:  | 1 "1"
  W%  e#   Reverse:            | 1 "1"
  n   e#   Print with newline: | 1
  )   e#   Increment:          | 2
}h    e# End loop
```
## To ><>:
```
"
```
Begins a string literal.
```
 la,:naonao
```
Content of the string literal. Each of the character codes is individually pushed to the stack.
```
"
```
The IP wraps around to reach `"` again, which ends string mode.
```
 la,
```
`l` takes the length of the stack, `a` pushes 10, and `,` divides. This gives us the length of the stack / 10.
```
    :nao
```
`:` duplicates, `n` prints as a number, `a` pushes 10, and `o` prints as a character code (a newline).
```
        nao
```
Same thing. Print the number followed by a newline. The stack now has length 10 again (the original string literal's content is on the stack).
The IP then wraps around to the `"` again, leading to 10 more elements to be pushed. Next time, `l` returns 20, so 2 is printed, etc.
The second line is never touched by the IP.
[Answer]
# [Röda](https://github.com/fergusq/roda)/[C (gcc)](https://gcc.gnu.org/), 90 bytes
```
main(){f(0);}f(a){a=1//1{[` $a`[::-1]];a++}while[]/*
;for(;;a++)printf("%d %d ",a,a);/**/}
```
[Röda: Try it online!](https://tio.run/##FcjBCoQgEADQ@35FRMGMGbNeG/oSERooSWhrkaCD@O1W8E4vHrOU8pOwAyYPX@TsQTDJaIhMslPVyGSHoTfOsXRdvtawLdaR@rA/IvCb@I9hPz3U7Vw9ai1akEkpyqXc "Röda – Try It Online")
[C: Try it online!](https://tio.run/##S9ZNT07@/z83MTNPQ7M6TcNA07o2TSNRszrR1lBf37A6OkFBJTEh2spK1zA21jpRW7u2PCMzJzU6Vl@Lyzotv0jDGiSoWVCUmVeSpqGkmqIAREo6iTqJmtb6Wlr6tf//AwA "C (gcc) – Try It Online")
### Explanation
This abuses the fact that `//` is int divison in Röda but a line comment in C.
In both languages, `main(){}` denotes the main program, and they both call function `f` with a dummy argument of `0`.
In Röda, `a=1//1` does int division and assigns the result `1` to `a`. C sees `a=1` and does the same thing, but everything after that assignment is a comment for C. From there, the two languages branch off.
**Röda**
We have an infinite loop with `while[]` ([an empty condition is truthy](https://codegolf.stackexchange.com/a/114401/41805)). Inside that, `` $a`` converts the integer `a` into a string (with a leading space) after which `[::-1]` reverses it (and it outputs with a trailing space). Then the value of `a` is incremented by one.
Outside of the while loop, a multiline comment starts `/*` and ends just before the end of the function.
**C**
After having ignored the rest of the line, the program goes to the second line. We start with a semicolon because the `a=1` statement needs to be terminated. After that, we encounter a simple for loop that prints the iterating variable, `a`, twice on each iteration.
Outside of the for loop, the `/*` is just there to ignore Röda's ending `*/` comment.
[Answer]
# [QBIC](https://drive.google.com/drive/folders/0B0R1Jgqp8Gg4cVJCZkRkdEthZDQ) / [QBasic 4.5](https://drive.google.com/open?id=0B0R1Jgqp8Gg4UVliSTE0MzdLcEU), 58 bytes
```
do
p=p+1
if q then
'?`_f!p$|
else
?p,p,
end if
loop
```
This heavily abuses the fact that all lowercase letters are seen as literal QBasic code by the QBIC interpreter and are therefor just passed along to the QBasic layer of QBIC. How both languages see this code, side by side:
```
LOC         QBasic                    QBIC
-------------------------------------------------------
do                   Start an infinite loop
p=p+1                Increment p, starts off as 0
if q then    q = 0, goto ELSE         q = 1, execute IF
'?`_f!p$|    ' = comment, invalid     '?` is a 'code literal', passing PRINT to QBASIC
             syntax is ignored        followed by QBIC code to flip p cast as string.
else         q=0, execute             q=1, so ignored
?p,p,        PRINT p twice,
             separated by tab
end if               End of the branching logic
loop                 Wrap around for the next pass
```
[Answer]
# [laserLANG](https://github.com/andlrc/laserLANG) / [><>](https://esolangs.org/wiki/Fish), 163 bytes
```
!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/
```
First time golfing, so it's a bit larger than it probably could be. I wanted to use ><>, but since a few people already used it to create the second sequence, I decided I wanted to give creating the first sequence a go.
[Try ><> online!](https://tio.run/##JYvBCsJAEEPv8xXZ1WLBDnGvZbv9EMdDL6JQLFjw99dZmkMeCcnzvb9qDXaDCcdrYgDw2DYTG5ces3t3XjAE4feuaSUjhkhh@GiXRpv7tAoMqkbkrE6hu/Ii1gj8hKV4fyotF4qhiccut@gfaM5O8ECUWKYy@coaWesf)  
For laserLANG, an offline interpreter is needed to try it. It can be found [here](https://github.com/andlrc/laserLANG).
**laserLANG** 
```
!\
 \ --\/ <<---\
/----/'
\----  v
/>>--\#>---->/
\     /
/----<
\  \
/ -<< \
 /<< \
 "
">=>= /
\>=>=/
```
execution starts at `!` which is ignored completely. it then reaches the `\` and starts traveling down past several characters that it completely ignores. Finally it reaches another `\` and the fun begins. I basically took the idea behind the "Hello, World!" loop and condensed it as well as I could. It was a bit of a challenge dealing with the fact that laserLANG is only about to decrement/increment the memory counter when the program counter is going left/right respectively. I feel like the most bytes could be saved here by doing some tricks I haven't thought of.
**><>** 
```
!\0 \
/:+1/!   ]oo\
\:a( ?\:a%$a ,!
/r[-1l//" ,"/
/!n-%1:\?(1l
```
Execution starts at `!` which causes it to skip the `\`. It then continues on as if the laserLANG code wasn't there. I didn't realize ><> *only* had support for float division, so a short and simple truncation was a bit confusing at first.
[Answer]
# [Befunge-98](https://pythonhosted.org/PyFunge/)/[><>](https://esolangs.org/wiki/Fish), 32 bytes
```
\r.#%a/# :_::p#+a#1,#
>l::naonao
```
Wrote this before I saw how many `><>` answers there were. Some background: `\` is a direction changing operator in ><>, in this case pushing it down, while in Befunge it swaps the top two items on the stack. The Befunge code looks like:
```
\r.#%a/# :_::p#+a#1,#
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//@PKdJTVk3UV1awireyKlDWTlQ21FHmMuCyM9S2sspLzAei//8B "Befunge-98 (PyFunge) – Try It Online")
Prints out the backwards numbers separated by newlines. Befunge prints a space automatically after each number, so each digit is separated by spaces. Repeatedly gets the last digit, prints it and divides the number by 10 until it is 0. Then increment and repeat.
The ><> code immediately goes down to the second line.
```
>l::naonao
```
[Try it online!](https://tio.run/##S8sszvj/P6ZIT1k1UV9ZwSreSltF2TBRWUFHmcsux8oqLzEfiP7/BwA "><> – Try It Online")
And is pretty simple. Get length of stack, print twice with newlines and leave a copy of the length on the stack for the next loop.
[Answer]
# [Ruby](https://www.ruby-lang.org/)/[Stacked](https://github.com/ConorOBrien-Foxx/stacked), 37 bytes
```
0#/0[1+:tostr rev out]
loop{p p$.+=1}
```
[Try it online!](https://tio.run/##KypNqvz/30BZ3yDaUNuqJL@4pEihKLVMIb@0JJYrJz@/oLpAoUBFT9vWsPb/fwA "Ruby – Try It Online")
This prints `1 1 2 2`... in Ruby and `1 2 3 ... 01 11 21...` in Stacked.
## Explanation
### In Ruby:
```
0#/0[1+:tostr rev out]
loop{p p$.+=1}
```
After removing the comment, this becomes:
```
0
loop{p p$.+=1}
```
The only relevant line here is the last. `p` returns its argument, so `p p` prints its argument twice. `$.` starts at `0`, so `$.+=1` increments `$.`, returning the incremented value. Therefore, this prints each number from `1` twice.
### In Stacked:
```
0#/0[1+:tostr rev out]
loop{p p$.+=1}
```
This is equivalent to the following tokens:
```
0 #/ 0 [ 1 + : tostr rev out ] loop { p p $ . + = 1 }
```
The first two are not relevant (basically, transforming `0` into a reduce f Unction). Then, `0` is pushed to the stack. After, the function `[1+:tostr rev out]` is pushed to the stack. `loop` pops this function and executes it infinitely.
The inside of the function increments the top of the stack (`1+`), duplicates it (`:`), converts it to a string (`tostr`), reverses it (`rev`) and outputs it (`out`). This process is repeated infinitely. Since the loop is infinite, anything that comes after that token is essentially ignored by the interpreter.
[Answer]
# [><>](https://esolangs.org/wiki/Fish) / [Jelly](https://github.com/DennisMitchell/jelly), 37 bytes (25 in Jelly's codepage)
```
01+:nao:nao!
DU;⁷Ṙ€
®‘©Çß
```
[Try ><> online!](https://tio.run/##S8sszvj/38BQ2yovMR@EFblcQq0fNW5/uHPGo6Y1XIfWPWqYcWjl4fbD8///BwA "><> – Try It Online")
[Try Jelly online!](https://tio.run/##ASoA1f9qZWxsef//MDErOjpubiEKRFU74oG34bmY4oKsCsKu4oCYwqnDh8Of//8 "Jelly – Try It Online")
**><>** prints the sequence to infinity twice, **Jelly** counts backwards.
**><>** is only concerned with the top line:
*And thanks to @Challenger5 for saving some bytes here on the linefeed*
```
01+:nao:nao!                           Stack at: 1st run   2nd run ...
0                 Push a 0             0         -
 1                Push a 1             0,1       1,1   
  +               Pop 2, add them      1         2 
   :              Duplicate top item   1, 1      2, 2
    n             Pop top, show as num 1         2
     a            Push the number 10   1, 10     2, 10
      o           Pop and show 10 as an ACII char (ie '\lf')
                                       1         2
         :nao     And again, for repetition
             !    ><> wraps around; this skips pushing a 0 again.
```
**Jelly** executes its code bottom-to-top. Only the last 2 lines are relevant.
```
®‘©Çß       main link, keeps track of the current number
®           Get a number from the register (0 on first run)
 ‘          Increment that by 1
  ©         Store in register
   Ç        Call helper (printer) link
    ß       Call this link again
DU;⁷Ṙ€      Printer
            (Say we are at number 21)
D           Break into digits         [2, 1]
 U          Reverse array             [1, 2]
  ;⁷        Append a line break       [1, 2, \n]
    Ṙ€      Print each char in array
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/)/[PHP](https://php.net/), ~~102~~ ~~86~~ 80 bytes
```
#//\
for(;;)echo strrev(++$i).'
int main(i){for(;;i++)printf("%d %d ",i,i);}//';
```
Outputs the double sequence in C and the reverse sequence in PHP.
[Try it in C!](https://tio.run/##S9ZNT07@/19ZXz@GKy2/SMPaWjM1OSNfobikqCi1TENbWyVTU0@dKzOvRCE3MTNPI1OzGqIsU1tbs6AIKJ6moaSaogBESjqZOpma1rX6@urW//8DAA "C (gcc) – Try It Online")
[Try it in PHP!](https://tio.run/##K8go@G9jXwAklfX1Y7jS8os0rK01U5Mz8hWKS4qKUss0tLVVMjX11Lky80oUchMz8zQyNashyjK1tTULioDiaRpKqikKQKSkk6mTqWldq6@vbv3/PwA "PHP – Try It Online")
## Explanations
### C
In C, the `#` forms preprocessor stuff. I don't really know much about C but it doesn't complain when there's any empty line for this stuff. The `//` forms a line comment. A `\` at the end of a line is essentially "escaping" the newline and making the two lines be treated as one. This also works for line comments, so the second line is seen as a comment in C. The third line does the work of outputting the numbers with a simple for loop. Afterwards, there is simply a comment.
### PHP
In PHP, `#` forms a line comment, so the first line is ignored entirely. The second line prints the numbers reversed with a for loop, and separates them with `\nint main(i){for(;;i++)printf("%d %d ",i,i);}//` (the C code wrapped in a string).
]