YASEPL, 132 bytes

=p'=n'(+`2£s©1`1=q)""=x=l®"p"`3=t$x!h¥t,"p"`4!x+}1,l,5!y¥x,"p"}3,h,4`5!f$x-tſ""!q+f+h!x}2,l,3!n-!p$q<!o$p(!s©o!pſ""!n}!s<!i+}2,n,2

prompts you twice. enter starting number and amount of iterations

Uiua, 13 bytes

⍥(♭≡◇⊂°⋕°▽)

Try it!

⍥(♭≡◇⊂°⋕°▽)
⍥(        ) # repeat n times:
       °⋕°▽ #   stringified RLE
   ♭≡◇⊂     #   prepend counts to values and flatten

Japt -h, 14 bytes

ÆV=ìÈòÎcÈâ iXÊ

Try it

Vyxal, 31 bits^v2, 3.875 bytes

(øeRf

Try it Online!

Bitstring:

0011010110011001011100101001100

inputs are reversed

J-uby, 41 bytes

Takes curried arguments with number of iterations first.

:**&(~(:gsub+:+%[:+@|S,~:[]&0])&/(.)\1*/)

Attempt This Online!

Non-regex solution, 47 bytes

:**&(A|:slice_when+:!=|:*&-[:+@,~:[]&0]|~:*&"")

Attempt This Online!

Go, 175 bytes

import."fmt"
func g(n int,s string)string{for N:=0;N<n;N++{c,o,f,k:=1,"",rune(s[0]),s[1:]+"_"
for _,r:=range k{if r==f{c++}else{o+=Sprintf("%d%c",c,f);f,c=r,1}}
s=o}
return s}

Attempt This Online!

A non-recursive port of Ogaday's answer.

Jelly, 6 bytes

ŒrUFµ¡

Try it online!

           Implicit input: first argument.
     µ¡    Do this to it <second argument> times:
Œr            Run-length encode into [value, times] pairs
  U           Flip them
   F          Flatten list
    

Husk, 11 bytes

!¡(dṁ§eL←gd

Try it online!

!              # get the arg2-th element of
 ¡             # the infinite list by repeatedly applying
               # (starting with arg1):
  (d           # get the digits of
    ṁ          # applying to each of 
         gd    # the groups of identical neighbouring digits:
     §eL←      # combine length + first element

GolfScript, 32 bytes

~{-1%1/(1@{.3$={;)}1if}/]{\+}*}*

Try it online!

Input with first arg as string, +2 bytes for first arg as num:

~{`-1%1/(1@{.3$={;)}1if}/]{\+}*~}*

05AB1E, 6 bytes

FÅγøí˜

Try it online!

FÅγøí˜  # full program
F       # for N in [0, 1, ...,
        # ..., implicit input...
F       # ... minus 1]...
     ˜  # flatten...
   ø    # zipped...
 Åγ     # list of chars used in runs of the same char in...
        # implicit input...
 Åγ     # or top of stack if not first iteration...
   ø    # with...
 Åγ     # list of lengths of runs of the same char in...
        # implicit input...
 Åγ     # or top of stack if not first iteration...
    í   # with each element of the list reversed
        # (implicit) exit loop
        # implicit output

øí can also be sø with no change in functionality. Try it online!

J, 26 bytes

2&([:;](#<@,{.);.1~1,~:/\)

Try it online!

05AB1E, 7 bytes

FÅγs.ιJ

Try it online!

Haskell, 62 bytes

import Data.List
0%y=y
x%y=do x<-group$(x-1)%y;[length x,x!!0]

Try it online!

R, 61 57 bytes

-4 thanks to @JayCe, just when I was sure it couldn't be done any simpler!

f=function(a,n)`if`(n,f(t(sapply(rle(c(a)),c)),n-1),c(a))

Try it online!

Python 3.6, 100 98 93 bytes

import re
f=lambda s,n:n and eval("f'"+re.sub(r'((.)\2*)',r'{len("\1")}\2',f(s,n-1))+"'")or s

Try it online!

Note this creates a lambda that takes a string and an integer, and returns a string. Example: f('1', 5) == '312211'

Finds all repeated characters (((.)\2*) regex), makes a f-string out of their length and the character itself (r'{len("\1")}\2'), then evaluates it. Uses recursion on the counter (n and ...f(s,n-1)... or s) to avoid having to define a proper function and a loop.

K (ngn/k), 30 bytes

{y{,/{(#x;*x)}'(&~=':x)_x}/,x}

Try it online!

Retina, 27 bytes

~(`^
K`
$
+`(.)\1$*¶$$.&$$1

Try it online!

Stax, 10 bytes

Çα▲ì4↔┌j█♀

Run and debug online!

Spent too many bytes on proper IO format ...

Explanation

Uses the unpacked version to explain.

DE|R{rm:f$e
D              Do `2nd parameter` times
 E             Convert number to digits
                   Starting from the `1st parmeter`
  |R           Convert to [element, count] pairs for each run
    {rm        Revert each pair
       :f      Flatten the array
         $     Convert array to string of digits
          e    Convert string of digits to integer

The essential part is D|R{rm:f(8 bytes).

If the first input can be taken as an array of digits, the whole program can be written in 9 bytes: Run and debug online!

APL (Dyalog Classic), 22 bytes

{∊(≢,⊃)¨⍵⊂⍨1,2≠/⍵}⍣⎕,⎕

Try it online!

SmileBASIC, 100 98 bytes

DEF S N,T?N
WHILE""<N
C=C+1C$=SHIFT(N)IF C$!=(N+@L)[0]THEN O$=O$+STR$(C)+C$C=0
WEND
S O$,T-T/T
END

Prints out all the steps. T/T is there to end the program when T is 0.

05AB1E, 9 bytes (Non-competing)

Corrected due to Emigna's comments, see below/edits.

F.¡vygyÙJ

Try it online!

R, 87 bytes

function(a,n){for(i in 1:n){r=rle(el(strsplit(a,"")));a=paste0(r$l,r$v,collapse="")};a}

Ungolfed & explained

f=function(a,n){
    for(i in 1:n){                      # For 1...n
        r=rle(el(strsplit(a,"")))       # Run length encoding
        a=paste0(r$l,r$v,collapse="")   # concatenate length vector and values vector and collapse
    };
    a                                   # print final result
}

Pylons, 11

i:At,{n,A}j

How it works:

i      # Get input from command line.
:A     # Initialize A
  t    # Set A to the top of the stack.
,      # Pop the top of the stack.
{      # Start a for loop.
 n     # Run length encode the stack.
  ,    # Seperate command and iteration
   A   # Repeat A times.
    }  # End for loop.
j      # Join the stack with '' and print it and then exit. 

Pyth, 10 8 bytes

-2 bytes by @FryAmTheEggman

ussrG8Qz

Explanation:

            Implicit: z=first line as string, Q=second line
u         the result of reducing lambda G:
  s s rG8   flattened run-length-encoded G
  Q       Q times
  z     starting with z
  

Try it here.

Retina, 46 45 27 bytes

Martin did lots to help golf this.

+`(\d)(\1?)*(?=.*_)_?
$#2$1

Try it online

Takes input in the format:

<start><count>

<start> is the initial number.

<count> is in unary, all underscores, and is how many iterations are performed.

Single iteration, 20 16 bytes:

(\d)(\1?)*
$#2$1

Mathematica, 81 73 bytes

FromDigits@Nest[Flatten[(Tally/@Split@#)~Reverse~3]&,IntegerDigits@#,#2]&

Perl, 38 + 2 bytes

for$i(1..<>){s/(.)\1*/(length$&).$1/ge}

Requires the -p flag:

$ perl -pe'for$i(1..<>){s/(.)\1*/(length$&).$1/ge}' <<< $'1\n5'
312211

Input is a multi line string:

input number
numbers of iterations

If all the steps are required as well then we can change it to the following, which is 44 + 2 bytes:

$ perl -nE'for$i(1..<>){s/(.)\1*/(length$&).$1/ge,print}' <<< $'1\n5'
11
21
1211
111221
312211

Python 3, 138 bytes

I used a recursive approach.

def g(a,b):
 if b<1:return a
 else:
  c,n=1,'';f,*a=str(a)+'_'
  for i in a:
   if i==f:c+=1
   else:n+=str(c)+f;f,c=i,1
  return g(n,b-1)

The function accepts two ints, a and b as described.

I'm amazed at how terse the entries here are! Maybe someone will come along with a better Python method too.

Perl 5, 50 bytes

$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say

The arguments are in reverse order (number of iterations then seed). Example:

> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 4 2
132112
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 0 2
2
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 2 0
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 1 10
1110
> perl -E'$_=pop;for$i(1..pop){s/(.)\1*/length($&).$1/ge}say' 11 1
3113112221232112111312211312113211

JavaScript ES6, 71 bytes

(m,n)=>[...Array(n)].map(_=>m=m.replace(/(.)\1*/g,x=>x.length+x[0]))&&m

Takes input as a string and a number.

Ruby, 63 bytes

A full program, since the question seems to ask for that. Takes input as command line arguments.

i,n=$*
n.to_i.times{i=i.gsub(/(.)\1*/){"#{$&.size}#$1"}}
puts i

^{No, gsub! can't be used, since the strings in $* are frozen :/}

JavaScript, 57 bytes

F=(a,b)=>b?F(a.replace(/(.)\1*/g,c=>c.length+c[0]),b-1):a

Recursion works well for this problem. The first parameter is the initial number as a string, and the second is the number of iterations.

CJam, 8 bytes

q~{se`}*

Input format is the initial number first, iterations second, separated by some whitespace.

Test it here.

Explanation

q~   e# Read and evaluate input, dumping both numbers on the stack.
{    e# Run this block once for each iteration...
  s  e#   Convert to string... in the first iteration this just stringifies the input
     e#   number again. In subsequent iterations it flattens and then stringifies the
     e#   array we get from the run-length encoding.
  e` e#   Run-length encode.
}*

The array is also flattened before being printed so the result is just the required number.

Perl 6, 63 bytes

say (@*ARGS[0],*.trans(/(.)$0*/=>{$/.chars~$0})…*)[@*ARGS[1]]

This is as short as I could get it for now, there might be some tricky flags that could reduce it, I'm not sure

MATL, 9 bytes

:"Y'wvX:!

Inputs are: number of iterations, initial number.

Try it online!

:      % implicit input: number of iterations. Create vector with that size
"      % for loop
  Y'   %   RLE. Pushes two arrays: elements and numbers of repetitions.
       %   First time implicitly asks for input: initial number
  w    %   swap
  v    %   concatenate vertically
  X:   %   linearize to column array
  !    %   transpose to row array
       % implicitly end loop
       % implicitly display