Haskell, 62 bytes

([1..]>>=).(!)

0!s=[|s<1]

n!s=[a:p|a<-[1..s],p<-(n-1)!(s-a)]

Try it online!

n!s generates all the n-tuples that sum to s.

Then the answer is ([1..]>>=).(!), i.e. n -> [t | s<-[1..], t<-n!s].

This is a function mapping an integer n to an infinite lazy list of tuples (lists of integers).

Husk, 2 bytes

πN

Try it online!

Explanation

N is the infinite list of natural numbers [1,2,3,4,...
π is Cartesian power.
Result is an infinite list of lists.
Each list of the desired length occurs exactly once because π is cool like that.
Input and output are implicit.

Perl 6, 37 bytes

{$++.polymod(1+$++ xx $_-1).say xx *}

Try it online!

Essentially runs polymod with as many entries as needed, where the modulo is always greater than the input, i.e. 0.polymod( 1,1,1 ), 1.polymod( 2,2,2 ) etc. That way the digit is always within the range. Perl6 won't let me modulo infinity...

Pyth - 10 bytes

Loops through all x, and takes [1..x]^n. This makes duplicates, so only keeps ones that are new to that x, aka contain x in them. The formatting is a little weird, but it can be made standard with one more byte, .V1jf}bT^Sb

.V1f}bT^Sb

Try it online.

Brachylog (v2), 9 bytes

~l.ℕᵐ+≜∧≜

Try it online!

This is an infinite generator that generates all possible tuples. The TIO link has a header that uses the generator to generate 1000 elements and prints them (but the generator could continue indefinitely if I asked for that instead; Brachylog's integers are unbounded).

It feels like there should be a terser way, but there are a lot of constraints and this is the tersest I can fit them into a single program.

Explanation

~l.ℕᵐ+≜∧≜

  .        Generate

        ≜  all explicit

~l         lists whose length is {the input}

    ᵐ      for which every element

   ℕ       is non-negative

     +     and whose sum

      ≜    is used to order the lists (closest to zero first)

       ∧   [remove unwanted implicit constraint]

Incidentally, it strikes me as interesting just how different my explanations of the two ≜ are, despite them doing the exact same thing from Brachylog's point of view. The first ≜ is the first nondeterministic predicate in the program, so it sets the order of results; in this case, it calculates all possible explicit values for the sum of the list in the order 0, 1, 2, 3…, and is being used to ensure that the lists are output in order of their sum (this ensures that each possible list appears after a finite amount of output). The second ≜ is used to calculate all the explicit possibilities for the list (rather than outputting a formula specifying how the elements of the list relate to each other).

Jelly, 10 (9?) bytes

^{9 if we may output using non-consistent separation (which I have enquired about) -- removal of the €.}

‘ɼṗ³ċƇ®Ṅ€ß

Try it online!

How?

‘ɼṗ³ċƇ®Ṅ€ß - Main Link: some argument, x (initially equal to n, but unused)

 ɼ         - recall v from the register (initially 0), then set register to, and yield, f(v)

‘          -   f = increment

           - (i.e. v=v+1)

   ³       - program's third command line argument (1st program argument) = n

  ṗ        - (implicit range of [1..v]) Cartesian power (n)

           - (i.e. all tuples of length n with items in [1..v])

     Ƈ     - filter keep those for which:

    ċ      -   count

      ®    -   recall from register

           - (i.e. keep only those containing v)

       Ṅ€  - print €ach

         ß - call this Link with the same arity

           - (i.e. call Main(theFilteredList), again the argument is not actually used)

05AB1E, 15 11 bytes

[¼¾LIãvy¾å—

-4 bytes by creating a port of @Maltysen's Pyth answer.

Try it online.

Explanation:

[             # Start an infinite loop:

 ¼            #  Increase the counter_variable by 1 (0 by default)

  ¾L          #  Create a list in the range [1, counter_variable]

    Iã        #  Take the cartesian power of this list with the input

      v       #  Loop over each list `y` in this list of lists:

       y¾å    #   If list `y` contains the counter_variable:

          —   #    Print list `y` with trailing newline

VDM-SL, 51 bytes

g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

Recursive set comprehension with sequence concatenation..

Not on TIO, you could run in a program (if you turn on limits for nat type or it wont terminate):

functions 

g:nat->set of ?

g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

Includes the optional 0s in answer otherwise it would be 52 bytes binding on nat1

MATL, 16 bytes

`@:GZ^t!Xs@=Y)DT

Tuples are ordered by increasing sum, and within a given sum they are ordered lexicographically.

Try it online!

Wolfram Language (Mathematica), 131 bytes

While[0<1,If[a~FreeQ~#,Print@#]&/@(b=Table[Select[Range@t~Tuples~{s},Tr@#==k&],{k,t,t(s=#)}]~Flatten~1);a={a}~Join~b;t++]&

t=1

a={}

Try it online!

perl -M5.010 122 bytes

$n=shift;

$s.="for$x$_(1..$m){"for 1..$n;

$t.="$x$_ "for 1..$n;

$u.='}'x$n;

eval"{$m++;$s$_=qq' $t';/ $m /&&say$u;redo}"

Added some newlines for readabilities sake (not counted in the byte count)

Wolfram Language (Mathematica), 62 bytes

Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&

Try it online!

-3 bytes with inconsistent separation (delete @#&)

Try it online!

Python 2, 126 112 106 101 bytes

n=input()

i=0;p=1

while 1:

 b=map(len,bin(i+p)[3:].split('0'));i=-~i%p;p<<=i<1

 if len(b)==n:print b 

Try it online!

5 bytes thx to mypetlion

Construct the ordered partitions of m into n bins, for m = 0,1,2,3,... by selecting for binary numbers with n-1 0s and m 1s.

Python3 (56 characters)

This runs, but never outputs/returns any values, because the permutations function keeps pulling numbers from count. But in theory, this would return the requested permutations.

from itertools import*

lambda n:permutations(count(1),n)

Proof that this works for limited integer range:

from itertools import*

l = lambda n: permutations(range(1, 10), n)

print(list(l(3)))  # returns all permutations of (1, 2, 3, ..., 10) of length 3