[Question]
  [
# Background:
A sequence of infinite naturals is a sequence that contains every natural number infinitely many times.
To clarify, **every number must be printed multiple times!**
# The Challenge:
Output a sequence of infinite naturals with the shortest code.
# Rules:
1. Each number must be separated by a (finite) amount of visible, whitespace or new line characters that aren't a digit.
2. The program cannot terminate (unless you somehow wrote all numbers).
3. Any way of writing such a sequence is acceptable.
# Examples:
```
1
1 2
1 2 3
1 2 3 4
1 2 3 4 5
1 2 3 4 5 6
1 2 3 4 5 6 7
...
```
`1, 1, 2, 1, 2, 3, 1, 2, 3, 4...`
Notice that we write all naturals from 1 to N for all N ‚àà ‚Ñï.
Feedback and edits to the question are welcome.
Inspired by my Calculus exam.
  
[Answer]
# [Scratch 3.0](https://scratch.mit.edu), ~~13~~ 20 blocks/~~121~~ 70 bytes
[![enter image description here](https://i.stack.imgur.com/YcRcI.png)](https://i.stack.imgur.com/YcRcI.png)
As SB Syntax:
```
define(n)(i
say(i
((n)+<(i)=(n)>)((1)+((i)*<(i)<(n
```
This says each term in the sequence. A delay can be added so that the numbers don't rapidly fire.
I have never seen scratch so abused. You call the *empty name* function with *empty parameters*. My goodness. Whatever saves bytes!
*-51 thanks to @att*
[Try it on Scratch](https://scratch.mit.edu/projects/456839468/)
## Explained
The main idea behind this program is that each "run" of natural numbers is printed until the value being printed is equal to the highest number of that run.
The first two lines of the function are pretty straightforward...define a function with parameters `n` (the upper limit of the current run of numbers) and `i` (the current number for printing), then output the value of `i`.
Then, we get to the fun part - the function call. The expression `n + (i = n)` determines if we need to move onto the next `n`: if `i` hasn't reached the upper limit, the expression evaluates as `n`. Otherwise, the expression is `n + 1`, giving us the next upper limit.
The expression `1 + (i * (i < n))` determines the next value of i. To properly understand this, consider the two different results `i < n` can evaluate to: if `i` is equal to `n` (that is, we have reached the upper limit of the current run and we need to consequently restart at 1), this will result in `(1 + (i * 0))`, which will always equal 1. However, if `i` is less than `n`, the expression will equal `(1 + (i * 1)) = (1 + i)` , which just happens to be the next value to print. Because there is no checks to see if execution should be halted, this goes on forever.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 2 bytes
```
·∏£N
```
[Try it online!](https://tio.run/##yygtzv7//@GOxX7//wMA "Husk ‚Äì Try It Online")
First Husk answer! Also uses the sequence in the question
## How it works
```
·∏£N - Main program
 N - The infinite list [1, 2, 3, ...]
·∏£  - Prefixes; [[1], [1, 2], [1, 2, 3], ...]
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 2 bytes
```
‚àûL
```
[Try it online!](https://tio.run/##yy9OTMpM/f//Ucc8n/9llYc3HN6r8x8A "05AB1E ‚Äì Try It Online") The footer formats the output like the example from the post.
`‚àû` pushes a list of all natural numbers, `L` takes the range `[1 .. n]` for each number.
[Answer]
# [Python 2](https://docs.python.org/2/), 31 bytes
```
R=1,
while 1:print R;R+=len(R),
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P8jWUIerPCMzJ1XB0KqgKDOvRCHIOkjbNic1TyNIU@f/fwA "Python 2 ‚Äì Try It Online")
Thanks to @Danis for saving a byte here over `R+=R[-1]+1,`. This
Prints:
```
(1,)
(1, 1)
(1, 1, 2)
(1, 1, 2, 3)
(1, 1, 2, 3, 4)
(1, 1, 2, 3, 4, 5)
    ...
```
Accumulates a list of number from 1 to n (except 1 appears twice) each time appending the last element plus one.
**32 bytes**
```
R=[1]
for x in R:print R;R+=x+1,
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P8g22jCWKy2/SKFCITNPIciqoCgzr0QhyDpI27ZC21Dn/38A "Python 2 ‚Äì Try It Online")
---
# [Python 2](https://docs.python.org/2/), 30 bytes (conjectured)
```
n=2
while 1:print~-2**n%n;n+=1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P8/WiKs8IzMnVcHQqqAoM6@kTtdISytPNc86T9vW8P9/AA "Python 2 ‚Äì Try It Online")
The sequence of \$2^n \bmod n\$ ([A015910](http://oeis.org/A015910)) is conjectured to take on all values \$k \geq 0\$ except \$k=1\$. I don't know if it's also conjectured that each value appears infinitely many times, but it seems consistent with [known solutions for specific values](http://oeis.org/wiki/2%5En_mod_n).
We instead compute \$(2^n-1) \bmod n\$, which makes \$0\$ rather than \$1\$ be the only missing value (if the conjecture holds).
Looking at the output, you might think that \$2\$ is never output, but it in fact [does appear](https://tio.run/##K6gsycjPM/r/P8/WxNzAwMDM2MTSnKugKDOvRKEgv1zDSCdPJ09T1/D/fwA "Python 2 ‚Äì Try It Online") first for \$n=4700063497\$ and for progressively higher values in [A050259](http://oeis.org/A050259).
---
# [Python 2](https://docs.python.org/2/), 33 bytes
```
R=[1]
for x in R:print x;R+=x+1,1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P8g22jCWKy2/SKFCITNPIciqoCgzr0ShwjpI27ZC21DH8P9/AA "Python 2 ‚Äì Try It Online")
This is longer, but it's pretty nifty, printing the [ABACABA sequence](https://en.wikipedia.org/wiki/ABACABA_pattern).
[Answer]
# [R](https://www.r-project.org/), ~~26~~ ~~25~~ 24 bytes
-1 byte thanks to Dominic van Essen
```
repeat cat(rpois(9,9)+1)
```
[Try it online!](https://tio.run/##K/r/vyi1IDWxRCE5sUSjqCA/s1jDUsdSU9tQ8/9/AA "R ‚Äì Try It Online")
Outputs a random infinite sequence of integers, drawn from the \$Poisson(9)\$ distribution (+1 to avoid outputting any 0s). They are output in batches of 9 at a time, for more "efficiency". Any positive value of the mean would work; using a mean of 9 maximizes the variance for 1-character numbers.
All numbers appear infinitely often in the sense that for any integer \$k\$, the expected number of occurences of \$k\$ in the first \$n\$ realizations goes to \$\infty\$ as \$n\to\infty\$:
$$E\left[\sum\_{i=1}^n\mathbb{I}\_{X\_i=k}\right]\xrightarrow[n\to\infty]{}\infty.$$
The calls to `cat` mean that there integers within one batch of 9 are separated by spaces, but there is no separator between batches. The vast majority of 3- and 4-digit numbers in the output are due to this artefact, but there is a theoretical guarantee that such numbers (and larger numbers) will be output eventually, at least if we assume that the underlying random number generator is perfect.
---
For a larger variance, we can follow Giuseppe's suggestion for the same byte count:
```
repeat cat(1%/%runif(9))
```
[Try it online!](https://tio.run/##K/r/vyi1IDWxRCE5sUTDUFVftag0LzNNw1JT8/9/AA "R ‚Äì Try It Online")
This induces more `1`s and more large numbers (including some very large numbers thanks to the `cat` artefact). Again, number of occurrences of any integer goes to infinity when the size of the output goes to infinity.
---
Two other R answers come out shorter, using deterministic methods: [Giuseppe's](https://codegolf.stackexchange.com/a/215795/86301) and [Dominic van Essen's](https://codegolf.stackexchange.com/a/215830/86301)
[Answer]
# [Haskell](https://www.haskell.org/), 17 bytes
```
[[1..x]|x<-[1..]]
```
[Try it online!](https://tio.run/##y0gszk7NyfmfYxvzPzraUE@vIramwkYXxIqN/Z@bmJmnYKtQUJSZV6KQ8/9fclpOYnrxf93kggIA "Haskell ‚Äì Try It Online")
Since the challenge seems to allow non-flat output, we can simply generate a list of the lists `[1],[1,2],[1,2,3,],...`, as suggested by @AZTECCO.
**[Haskell](https://www.haskell.org/), 19 bytes**
```
l=1:do x<-l;[x+1,1]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P8fW0ColX6HCRjfHOrpC21DHMPZ/bmJmnoKtQkFRZl6JQs7/f8lpOYnpxf91kwsKAA "Haskell ‚Äì Try It Online")
A recursively-defined infinite flat list with the [ABACABA sequence](https://en.wikipedia.org/wiki/ABACABA_pattern) `1,2,1,3,1,2,1,4,...` ([A001511](https://oeis.org/A001511)).
A same-length variant:
```
l=(:[1]).succ=<<0:l
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P8dWwyraMFZTr7g0OdnWxsbAKud/bmJmnoKtQkFRZl6JQs7/f8lpOYnpxf91kwsKAA "Haskell ‚Äì Try It Online")
**20 bytes**
```
l=do x<-[1..];[1..x]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P8c2JV@hwkY32lBPL9YaRFbE/s9NzMxTsFUoKMrMK1FQUShJzE5VMDQwUMj5/y85LScxvfi/bnJBAQA "Haskell ‚Äì Try It Online")
Counting up `1,1,2,1,2,3,1,2,3,4,...`, but as a flat list.
[Answer]
# [R](https://www.r-project.org/), 21 bytes
*(also near-simultaneously identified by Robin Ryder)*
```
while(T<-T+1)cat(T:0)
```
[Try it online!](https://tio.run/##K/r/vzwjMydVI8RGN0TbUDM5sUQjxMpA8/9/AA "R ‚Äì Try It Online")
Similar to the example sequence, but each sub-series is reversed, and the initial value in each subseries is represented with an initial zero (so, `03` for 3, for instance).
If you don't like the initial zeros, then look at the previous version using `show` (below), or at [Giuseppe's answer](https://codegolf.stackexchange.com/a/215795/95126).
---
# [R](https://www.r-project.org/), ~~23~~ 22 bytes
*Edit: -1 byte thanks to Robin Ryder*
```
while(T<-T+1)show(1:T)
```
[Try it online!](https://tio.run/##K/r/vzwjMydVI8RGN0TbULM4I79cw9AqRPP/fwA "R ‚Äì Try It Online")
Outputs the sequence used in the example, plus an additional infinite number of copies of the number `1`.  
Each number is separated by either a space "" , a newline plus bracket, "`\n[`", or a bracket plus space "`[` ".
2-bytes golfier (at time of posting, at least...) than the [other](https://codegolf.stackexchange.com/a/215795/95126) [two](https://codegolf.stackexchange.com/a/215783/95126) [R](https://www.r-project.org/) answers...
[Answer]
# [Bash](https://www.gnu.org/software/bash/) + GNU Coreutils, 20
```
seq -fseq\ %g inf|sh
```
[Try it online!](https://tio.run/##S0oszvj/vzi1UEE3DUjGKKimK2TmpdWARAE "Bash ‚Äì Try It Online") - Times out after 60 seconds.
[Answer]
# [Bash](https://www.gnu.org/software/bash/), 20 bytes
```
seq inf|xargs -l seq
```
[Try it online!](https://tio.run/##S0oszvj/vzi1UCEzL62mIrEovVhBN0cBKPD/PwA "Bash ‚Äì Try It Online")
[Answer]
# [sed 4.2.2](https://www.gnu.org/software/sed/), 20
```
:;s/(1*).*/1\1 &/p;b
```
[Try it online!](https://tio.run/##K05N@f/fyrpYX8NQS1NPS98wxlBBTb/AOun//3/5BSWZ@XnF/3WLAA "sed 4.2.2 ‚Äì Try It Online")
Output is in unary, as per [this meta consensus](https://codegolf.meta.stackexchange.com/a/5349/11259).
[Answer]
# [Befunge](https://esolangs.org/wiki/Befunge), 5 bytes
```
>1+?.
```
[Try it online!](https://tio.run/##S0pNK81LT/3/385Q217v/38A)
At each output, there is a 50% chance the current number will be printed and reset to 1, and a 50% chance that `2` will be printed and the current number will increase by some random odd number (following an exponential distribution). This can happen multiple times, so odd numbers can be outputted as well.
Every natural number has a nonzero probability of occurring, so it will eventually be printed infinitely many times.
### Explanation
```
>1+?.
>      # Go east.
 1+    # Initialize a counter to 1.
   ?   # Go in a random direction.
       # If the instruction pointer goes west:
  +    # Add the top two stack elements together.
       # If there is a 2 on top, this adds it to the counter.
       # If not, this does nothing.
 1     # Create a new 1 on the top of the stack.
>      # Go east.
 1+    # Add 1 to get 2, which remains on top of the counter.
   ?   # Repeat.
       
   ?   # If the IP goes east:
    .  # Print and delete the top of the stack.
>      # Go east.
 1+    # Add 1.
       # If there was a 2 that was printed and the counter remains, the 1 gets added to it.
       # If the counter was printed instead, this creates a new 1.
   ?   # Repeat.
   ?   # If the IP goes north or south, it wraps around to the ? instruction and repeats.
```
---
# [Befunge-98](https://esolangs.org/wiki/Funge-98), 14 bytes
```
]:.1-:0`j
]:+!
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//@PtdIz1LUySMjiirXSVvz/HwA)
A determinstic solution, printing each range from 1 to `n` in descending order.
### Explanation
```
]           # Turn right (to the south) and go to the second line.
]:+!      
]           # Turn right again (to the west).
   !        # Take the logical NOT of the secondary counter (which is now 0) to get 1.
  +         # Add the 1 to the main counter.
 :          # Duplicate the main counter to form a secondary counter.
]           # Turn right (to the north) and go to the first line.
]:.1-:0`j 
]           # Turn right (to the east).
 :          # Duplicate the secondary counter.
  .         # Print and delete the duplicate.
   1-       # Subtract 1 from the secondary counter.
     0`     # Is the secondary counter greater than 0?
       j    # If so, jump over the ] instruction and repeat the first line.
]           # If not, turn right (to the south) and go to the second line.
```
[Answer]
# [convey](http://xn--wxa.land/convey/), 27 bytes
```
   >v
1","@"}
^+^<#-1
1+<<<
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoiICAgPnZcbjFcIixcIkBcIn1cbl4rXjwjLTFcbjErPDw8IiwidiI6MSwiaSI6IiJ9)
[![enter image description here](https://i.stack.imgur.com/ftjPR.gif)](https://i.stack.imgur.com/ftjPR.gif)
This counts down from successive numbers.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 4 bytes
```
‚ÄòR·πÑ√ü
```
[Try it online!](https://tio.run/##y0rNyan8//9Rw4yghztbDs///x8A "Jelly ‚Äì Try It Online")
I think this outputs all numbers an infinite number of times, but because it's a different output format, I'm not 100% sure
## How it works
```
‚ÄòR·πÑ√ü - Main link. Left argument is initially n = 0
‚Äò    - Increment
 R   - Range
  ·πÑ  - Print
   √ü - Recursively run the main link
```
For `n = 0`, `‚ÄòR·πÑ` outputs `[1]`. We then recurse, using `n = [1]`. `‚ÄòR·πÑ` then outputs `[[1, 2]]`, and we recurse again, using `n = [[1, 2]]`, which outputs `[[[1, 2], [1, 2, 3]]]` etc.
[Answer]
# [Octave](https://www.gnu.org/software/octave/), ~~29~~ 28 bytes
```
do disp(fix(1/rand)) until 0
```
[**Try it online!**](https://tio.run/##y08uSSxL/f8/JV8hJbO4QCMts0LDUL8oMS9FU1OhNK8kM0fB4P9/AA)
This outputs a sequence \$(x\_k)\$ of independent, identically distributed random natural numbers. Each value \$x\_k\$ is obtained as \$1/r\$ rounded towards zero, where \$r\$ has a uniform distribution on the interval \$(0,1)\$.
For a given index \$k\$, and for any \$n \in \mathbb N\$, there is a nonzero probability that \$x\_k=n\$ (ignoring floating-point inaccuracies). Therefore, with probability \$1\$ every \$n\$ appears infinitely often in the sequence \$(x\_k)\$.
[Answer]
# [R](https://www.r-project.org/), ~~25~~ 21 bytes
```
repeat T=print(T:0+1)
```
[Try it online!](https://tio.run/##K/r/vyi1IDWxRCHEtqAoM69EI8TKQNtQ8/9/AA "R ‚Äì Try It Online")
Prints `2..1, 3..1, 4..1` and so forth.
Thanks to Robin Ryder for -4 bytes.
This works because `print` invisibly returns its first argument.
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 43 bytes
```
i;main(j){for(;;)printf("%d ",j=--j?:++i);}
```
[Try it online!](https://tio.run/##S9ZNT07@/z/TOjcxM08jS7M6Lb9Iw9pas6AoM68kTUNJNUVBSSfLVlc3y95KWztT07r2/38A "C (gcc) ‚Äì Try It Online")
[Answer]
# [JavaScript (V8)](https://v8.dev/), 26 bytes
```
for(a=b='';;)write(a+=--b)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/Py2/SCPRNslWXd3aWrO8KLMkVSNR21ZXN0nz/38A "JavaScript (V8) ‚Äì Try It Online")
Character `-` used as a separator and the output starts with it, so I'm not really sure if this is acceptable.
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 25 bytes
```
Do[Print@n,{m,‚àû},{n,m}]
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78/98lPzqgKDOvxCFPpzpX51HHvFqd6jyd3NrY////AwA "Wolfram Language (Mathematica) ‚Äì Try It Online")
-1 byte @att
[Answer]
# [convey](http://xn--wxa.land/convey/), 17 15 bytes
*-2 thanks to Jo King!*
```
>1\/v
:+<.+}
11
```
[Try it online!](https://xn--wxa.land/convey/run.html#eyJjIjoiPjFcXC92XG46KzwuK31cbjExIiwidiI6MSwiaSI6IiJ9)
Previous version that used a 0-stream and incremented its indices by 1. Jo's variation uses a 1-stream that adds itself to its indices, thus shortening the last row.
[![left part](https://i.stack.imgur.com/3NzM5.gif)](https://i.stack.imgur.com/3NzM5.gif)
Starting with the top left `0`, we push it to the left. `\` will push its length `1` downward, it will get incremented `+1` and then `length + 1` new 0s will be let through. So we generate `0`, `0 0`, `0 0 0`, ‚Ä¶
[![first 30 steps](https://i.stack.imgur.com/Tp0ci.gif)](https://i.stack.imgur.com/Tp0ci.gif)
Those list get then dumped in a sink `]` while their indices `\.` get incremented `+1` and written to the output `}`: `1`, `1 2`, `1 2 3`, ‚Ä¶
[Answer]
# [Regenerate](https://github.com/dloscutoff/Esolangs/tree/master/Regenerate) `-a`, 14 bytes
```
(${$1+1} !1 )+
```
[Attempt This Online!](https://ato.pxeger.com/run?1=m72qKDU9NS-1KLEkdVm0km6iUuyCpaUlaboW6zRUqlUMtQ1rFRQNFTS1IYJQuQVQGgA)
The only choice for the regex to make here is how many times to repeat the `(`...`)+` loop. The first iteration will always print `1` , because the first alternative can't match, as `$1` hasn't been defined yet.
On subsequent iterations, `${$1+1}` does math on `$1`, treating its contents as a number. It ignores the trailing space, and adds 1 to it. This then becomes the new value for `$1`, etc.
The `!` short-circuiting alternation prevents the second alternative, i.e. `1` , from being taken once it becomes possible for the first alternative, `${$1+1}` , to match.
[Answer]
## Arm Thumb (with libc calls), 34 bytes
Raw machine code
`f7ff fffe` is for libc calls which haven't been linked yet.
Needs to be loaded at an address that is **not** a multiple of 4, due to alignment requirements. Yes, it is counterintuitive, but it will make sense later.
```
2400 a707 3401 2501 0038 0029 f7ff fffe
3501 42a5 d9f8 200a f7ff fffe e7f2 7525
0020
```
Uncommented Assembly
```
        .thumb
        .globl main
        .thumb_func
main:
        movs    r4, #0
        adr     r7, str
.Lloop1:
        adds    r4, #1
        movs    r5, #1
.Lloop2:
        movs    r0, r7
        movs    r1, r5
        bl      printf
        adds    r5, #1
        cmp     r5, r4
        bls     .Lloop2
.Lloop2_end:
        movs    r0, #'\n'
        bl      putchar
        b       .Lloop1
str:
        .asciz "%u "
```
### Explanation
Equivalent C code:
```
#include <stdio.h>
#include <stdint.h>
int main(void)
{
    uint32_t N = 0;
    for (;;) {
        ++N;
        for (uint32_t num = 1; num <= N; num++) {
            printf("%u ", num);
        }
        putchar('\n');
    }
    // Unreachable
}
```
Since we are never returning from `main`, I say, "to hell with calling convention" and just overwrite the callee-saved registers with our local variables. They won't know the difference. üòà
Specifically, I want r4 to be N (it is incremented before using), and r7 to be our printf string.
Unfortunately, we have an odd number of instructions, and `adr` can only load addresses that are 4 byte aligned, so we need to make `main` *not* be 4-byte aligned so the string *is* 4-byte aligned.
```
main:
        movs    r4, #0
        adr     r7, str
```
Begin printing the natural numbers. Increment N and start counting ‚Ñï in r5.
```
.Lloop1:
        adds    r4, #1
        movs    r5, #1
```
`printf("%u ", ‚Ñï)`
```
.Lloop2:
        movs    r0, r7
        movs    r1, r5
        bl      printf
```
Increment ‚Ñï and loop while it is less than or equal to N.
```
        adds    r5, #1
        cmp     r5, r4
        bls     .Lloop2
```
After the second loop: `putchar('\n')`
```
.Lloop2_end:
        movs    r0, #'\n'
        bl      putchar
```
Jump back to the outer loop to increment N.
```
        b       .Lloop1
```
The printf string. This must be 4-byte aligned for `adr`, which we do with how we load `main`.
```
str:
        .asciz "%u "
```
[Answer]
# [Brachylog](https://github.com/JCumin/Brachylog), 4 bytes
```
‚ü¶‚ÇÅ·∫â‚ä•
```
[Try it online!](https://tio.run/##SypKTM6ozMlPN/r//9H8ZY@aGh/u6nzUtfT/fwA "Brachylog ‚Äì Try It Online")
```
  ·∫â     Print with a newline
‚ü¶‚ÇÅ      the range from 1 to something,
   ‚ä•    then try again.
```
[Answer]
# [J](http://jsoftware.com/), 13 bytes
```
$:@,~[echo@#\
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/VawcdOqiU5Mz8h2UY/5rcoFYCmkKBv8B "J ‚Äì Try It Online")
Outputs `1`, `1 2`, `1 2 3 4`, `1 2 3 4 5 6 7 8`, etc, with every number on its own line.
* `echo@#\` Output the prefix lengths of the current list, ie, `1..n` where n is the current list length. This is done as a side effect.
* `$:@,~` Append the list to itself `,~` and call the function recursively `$:@`.
[Answer]
# [Rust](https://www.rust-lang.org/), 54 bytes
```
(2..).for_each(|x|(1..x).for_each(|y|print!("{} ",y)))
```
[Try it online](https://tio.run/##KyotLvmflqeQm5iZp6GpUP1fw0hPT1MvLb8oPjUxOUOjpqJGw1BPrwJZqLKmoCgzr0RRQ6m6VkFJp1JTU/N/7X8A)
[Answer]
# [Ruby](https://www.ruby-lang.org/), 17 bytes
```
loop{p *1..$.+=1}
```
[Try it online!](https://tio.run/##KypNqvz/Pyc/v6C6QEHLUE9PRU/b1rD2/38A "Ruby ‚Äì Try It Online")
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 8 bytes
```
Ôº∑¬π¬´Ôº©‚äï‚ÖâÔº§‚∏ø
```
[Try it online!](https://tio.run/##S85ILErOT8z5/788IzMnVUHDUFOhmoszoCgzr0TDObG4RMMzL7koNTc1ryQ1RSNLU1PTmovTpTS3QAPEgChTiilSAvJq////r1uWAwA "Charcoal ‚Äì Try It Online") Link is to verbose version of code. Works by repeatedly printing the next number to the canvas and then dumping the entire canvas.
2 bytes for a version that prints the \$ n \$th term of a sequence:
```
Ôº©Œ£
```
[Try it online!](https://tio.run/##S85ILErOT8z5///9npXnFv//b2hkbGJqZm5hCQA "Charcoal ‚Äì Try It Online") Explanation: Simply prints the digital sum of the input. Given any natural number \$ n \$, all the values of the form \$ \frac { 10 ^ n - 1 } 9 10 ^ m \$ have a digital sum of \$ n \$ for every \$ m \$, thus each natural number appears infinitely often.
[Answer]
# [JavaScript (V8)](https://v8.dev/), 29 bytes
```
for(n=k=1;;)print(n=--n||k++)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNEts/j/Py2/SCPPNtvW0Npas6AoM68EyNPVzaupydbW1vz/HwA "JavaScript (V8) ‚Äì Try It Online")
[Answer]
# [Factor](https://factorcode.org/), 32 bytes
```
1 [ dup bit-count . 1 + t ] loop
```
[Try it online!](https://tio.run/##HcqxCoAgFEbhvaf490hwrQcIl5ZoigYzI8lSbleip7doOct3Vm04UB561bU1dkun9Tg0b3/E7Ph2l0Uky/xEciejKVRX4zKk2WxZYsSSIr6zMiF9LiBRgjHBhxBzfgE "Factor ‚Äì Try It Online")
Loops over the positive integers and prints their bit count (the number of 1 bits, a.k.a. popcount) forever. Outputting nth term would be simply 9-bytes `bit-count`. (I checked that the function works with bigints.)
Uses the same logic as [Neil's Charcoal answer](https://codegolf.stackexchange.com/a/215794/78410) that there are infinitely many numbers whose digit sum equals n, except that this one uses bits instead. More precisely, for any positive integer n, \$2^m(2^n-1)\$ for any non-negative integer m has exactly n bits on, so the sequence contains infinitely many n's for any n.
[Answer]
# JavaScript (Browser), 40 bytes
```
f=(x=1)=>setInterval(_=>alert(x,f(x+1)))
```
Not very competitive answer :(
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~52~~ ~~49~~ 44 bytes
Saved 5 bytes thanks to [AZTECCO](https://codegolf.stackexchange.com/users/84844/aztecco)!!!
```
f(i,j){for(j=1;printf("%d ",j--);)j=j?:++i;}
```
[Try it online!](https://tio.run/##DcFBCoAgEADAu68QIdglPXRNpLeIseFSFhZ0kL7e1kxyS0oiBNkyNtorcBj8UXO5CEw3a2PZOfTIgaex77N/ZIu5AOqm9I8AvXrkTbTG5RR3fw "C (gcc) ‚Äì Try It Online")
]