Perl 6, 24 23 bytes

-1 byte thanks to nwellnhof

{.put;.X~(6...1)}...*

Try it online!

Outputs the sequence infinitely separated by spaces/newlines. Or, for a few more bytes we can have a lazy infinite list we can index into instead.

Perl 6, 27 bytes

{flat {@=.X~(6...1)}...*}

Try it online!

Explanation:

{                         }    # Anonymous code block

 flat                          # Return the flattened

                      ...*       # Infinite sequence

      {              }             # Defined as

         .                       # The previous element arrayified

            X~                     # Each concatenated with

              (6...1)              # All of 6 to 1

       @=                          # Arrayified

Python 2, 39 38 34 bytes

f=lambda n:n and-n%6+1+f(~-n/6)*10

Try it online!

Outputs 1-indexed number

R, 43 bytes

p='';repeat cat(p<-sapply(p,paste0,6:1),'')

Try it online!

Prints the sequence indefinitely

• -9 thanks to @Kirill L.

Bash, 31 bytes

f()(x+={6..1};eval echo $x;f);f

TIO

update from comments, the n'th value 1-indexed, +GNU tools + perl, 64 bytes, 7 bytes saved thanks to @manatwork

dc<<<6o$1p|perl -pe 's/(.)0/($1-1).6/e?redo:s/0//'|tr 1-6 654321

64 bytes

MATL, 11 bytes

`6:P!V@Z^DT

Outputs the values indefinitely.

Try it online!

Explanation

`      % Do...while

  6:   %   Push [1 2 3 4 5 6]

  P    %   Flip: gives [6 5 4 3 2 1]

  !    %   Transpose: turns the row vector into a column vector

  V    %   Convert the number in each row to the corresponding char

  @    %   Push current iteration index, starting from 1

  Z^   %   Cartesian power. Gives a matrix where each row is a Cartesian tuple

  D    %   Display immediately

  T    %   Push true. This is used as loop condition, to give an infinite loop

       % End (implicit)

Haskell, 38 34 bytes

An infinite list of numbers:

d=[6,5..1]

l=d++[10*m+n|m<-l,n<-d]

Try it online!

Two earlier solutions that give infinite lists of strings, each using 38 bytes:

[1..]>>=sequence.(`replicate`"654321")

Try it online!

do n<-[1..];mapM id$[1..n]>>["654321"]

Try it online!

JavaScript (ES6), 26 bytes

Returns the $n$^th term, 1-indexed.

f=n=>n--&&[f(n/6|0)]+6-n%6

Try it online!

Haskell, 28 bytes

l=(+).(10*)<$>0:l<*>[6,5..1]

Try it online!

Produces an infinite list of numbers l. Using <$> and <*> cuts a byte off:

29 bytes

l=[10*n+d|n<-0:l,d<-[6,5..1]]

Try it online!

The approach is similar to the Haskell Output All String answer fixed input string "654321", and skipping the empty string output by changing where it's prepended.

30 bytes

l=[n++[d]|n<-"":l,d<-"654321"]

Try it online!

05AB1E, 10 bytes

Outputs the sequence indefinitely.

¸[6LRâJD»,

Try it online!

Explanation

¸           # initialize the stack with a list containing the empty string

 [          # loop

  6L        # push [1 ... 6]

    R       # reverse

     â      # cartesian product

      J     # join each inner list

       D    # duplicate (saving a copy for next iteration)

        »,  # join on newline and print

Perl 5, 40 37 bytes

-3bytes thanks to @Xcali

map{say}<"$_">while s//{6,5,4,3,2,1}/

37 bytes

40 bytes

Java (JDK), 48 bytes

String f(int n){return n-->0?f(n/6)+(6-n%6):"";}

Try it online!

This returns the 1-indexed n^th element.

Recursion seems to beat the iterative lambda.

Iterative version, 49 bytes

n->{var r="";for(;n-->0;n/=6)r=6-n%6+r;return r;}

Try it online!

Brachylog, 13 11 bytes

Thanks to Fatalize for 2 bytes

6~d{⟧₁∋}ᵐẉ⊥

Outputs indefinitely. Try it online!

Here's a 14-byte version that outputs the first $n$ values: Try it online!

Explanation

6~d           Start with a number, all of whose digits are 6's

              Brachylog considers these in the order 6, 66, 666, 6666...

   {   }ᵐ     Map this predicate to each of those digits:

    ⟧₁         1-based reverse range: [6,5,4,3,2,1]

      ∋        The output digit must be a number in that range

              Brachylog considers possible outputs in this order: 6, 5, 4, 3, 2, 1, 66, 65...

         ẉ    Write a possible output with newline

          ⊥   Force the predicate to fail and backtrack to the next possibility

C# (.NET Core), 38 bytes

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;

Try it online!

Outputs the n-th value (1-based).

Japt, 14 bytes

There's gotta be a shorter solution using function methods and/or Cartesian product but (for now?) the best I can manage is a port of Arnauld's JS solution so be sure to upvote him too.

©ß´Uz6)s+6-Uu6

Try it or test terms 0-1000

Wolfram Language (Mathematica), 88 78 bytes

(l=d=c=7-Range@6;While[Length@c<#,d=Flatten[(10#+l)&/@d];c=c~Join~d;];c[[#]])&

Try it online!

saved 4 + 6 bytes thanks to @IanMiller

List is 1 indexed, outputs the n'th number.

Mathematica, 56 bytes

Flatten[FromDigits/@Tuples[7-Range@6,#]&/@Range@#][[#]]&

Requires excessive amounts of memory to actually run as it creates all numbers in the sequence which have length equal to or less than the input (i.e. it creates $frac{6}{5}(6^n-1)$ terms) then takes the required value from the list. For practice use replace the second last # with a specific value for the length you want to use it on.

Pip -l, 16 bytes

x:YP6-,6W1PxCP:y

Outputs the sequence indefinitely. Try it online!

Explanation

The -l flag means that lists are printed with each item on its own line; if an item is itself a list, its elements are concatenated with no separator. E.g. the list [1 [2 3] [4 [5 6]]] would be printed as

1

23

456

With that cleared up:

x:YP6-,6W1PxCP:y

      ,6          Range(6): [0 1 2 3 4 5]

    6-            Subtract each element from 6: [6 5 4 3 2 1]

  YP              Yank that value into the y variable, and also print it

x:                Assign that value also to x

        W1        While 1 (infinite loop):

           xCP:    Assign to x the cartesian product of x with

               y   the list [6 5 4 3 2 1]

          P        Print it

After the first loop iteration, x looks like [[6;6];[6;5];[6;4];...;[1;1]]; after the second iteration, [[[6;6];6];[[6;6];5];[[6;6];4];...;[[1;1];1]]; and so on. We don't need to worry about flattening the sublists, because -l effectively does it for us.

Charcoal, 18 bytes

ＮθＷθ«←Ｉ⊕﹪±θ⁶≔÷⊖θ⁶θ

Try it online! Link is to verbose version of code. 1-indexed. Explanation:

Ｎθ

Input n

Ｗθ«

Repeat until n is zero.

←Ｉ⊕﹪±θ⁶

Reduce -n modulo 6, then increment the result and output from right to left.

≔÷⊖θ⁶θ

Decrement n and integer divide it by 6.

Retina 0.8.2, 36 bytes

.+

$*_

+`(_*)1{5}(_+)

$1$.2

T`7-1`d

Try it online! Link includes test cases. 1-indexed. Explanation:

.+

$*_

Convert to unary. (Retina 1 would save 2 bytes here.)

+`(_*)1{5}(_+)

$1$.2

Convert to bijective base 6 by repeated divmod. Note that the use of + means that the extracted digit is always a number from 1 to 6 instead of 0 to 5 for regular base 6 conversion. ((_{6})* is faster but costs bytes extracting the quotient.)

T`7-1`d

Transpose the digits so that the 6s come first and the 1s last. (There are no 7s or 0s but this allows me to use the d shortcut.

Cubix, 22 bytes

This will output the sequence indefinitely. The general idea is that it has a base number which 6 - 1 is added to. For each add the result is output multiplied by 10, which is pushed to the bottom of the stack to be used later in the sequence. The base is then popped and the next base started.

..w.06+ONo*w;|uW!(pq;;

Try it online!

    . .

    w .

0 6 + O N o * w

; | u W ! ( p q

    ; ;

    . .

Watch It Run

C# (.NET Core), infinite printing, 181 180 88 bytes.

string s=new string{" "},t;int i,j,k,l=1;while(true){j=l;t=new string[l=6*j];for(i=6;i>0;i--)for(k=(6-i)*j;k<l;)t[k]=i+s[k++%j];

for(k=0;k<l;)System.Console.Write(t[k++]);s=t;}

Sadly it freezes repl.it instead of outputting properly in the infinite version as written (I believe it to be an error in repl.it, as it does not output as the program loops like it should), so anyone hoping to test needs a computer. If you add a read at the front of the loop it works in repl.it as well.

Outputs to the console, obviously.

On any finite system the code will most likely eventually crash with an out of memory error.

Reworked the code to use @dana 's lambda.

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;++i>0;)System.Console.Write(f(i)+" ");

Try it online!

Forth (gforth), 63 bytes

: f recursive dup 6 < if 6 - abs 1 .r else 6 /mod 1- f f then ;

Try it online!

0-indexed outputs nth value

Explanation

If N is less than 6, output the absolute value of N - 6. Otherwise, get the quotient and remainder of dividing N by 6. Call the function recursively on the quotient, then call it on the remainder.

Code Explanation

: f                  start a new word definition

  recursive          declare that this word is recursive so we can call it from itself

  dup 6 <            check if n is less than 6

  if                 if it is:

    6 - abs 1 .r     subtract 6, get the absolute value, then print with no appended space

  else               else if it's greater than 6:

    6 /mod           get the quotient and remainder of dividing n by 6

    1-               subtract 1 from the quotient (because we're 0-indexed)

    f                call f on the result

    f                call f on the remainder (shortcut to format and print, it's always < 6)

  then               end the if/else

;                    end the word definition

APL(NARS), 27 chars, 54 bytes

{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}

traslate the solution by dana https://codegolf.stackexchange.com/a/179980 in APL...
test:

  f←{0>⍵-←1:0⋄(6-6∣⍵)+10×∇⌊⍵÷6}

  f 500

5625

  f¨750 1000 9329 9331 10000 100000

4531 3433 11112 666666 663633 6131233 

  f¨⍳9

6 5 4 3 2 1 66 65 64 

C#, print from start to n, ??? bytes

Credit to @dana for the lambda expression.

int f(int n)=>n-->0?f(n/6)*10+6-n%6:0;for(int i=0;i<int.Parse(a[0]);)System.Console.Write(f(++i)+" ");

Operation: Run with command line 0th argument equal to the integer you want to count to. (It should be noted that a[0] is a reference to the otherwise unmentioned command line args array, and I don't know how to count it.)