text:
Print a 10 by 10 grid of asterisks
Background
This is a standard textbook example to demonstrate for loops.
This is one of the first programs I learnt when I started learning programming ~10 years ago.
Task
You are to print this exact text:
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Specs

You may have extra trailing newlines.
You may have extra trailing spaces (U+0020) at the end of each line, including the extra trailing newlines.

Scoring
This is code-golf. Shortest answer in bytes wins.

I'm not that familiar with this. The chrome dev tools print repetition on one line. e.g, here it would print (10)********** is that acceptable, as we know it's a dev-tool 'optimisation'?

@DylanMeeus "You are to print this exact text:"

@DylanMeeus Since that is to do with the dev tools hiding repeated console outputs, and isn't native to JavaScript consoles as a whole and is not in the JavaScript spec - as well as the fact that feature can be turned off - i think it should be acceptable. Not all browsers will collapse it like that.

@JamesTrotter oh I didn't notice that it can be turned off, cheers!

@LeakyNun Leaderboard snippet please!

One of the most interesting things about this challange is that depending on your language ********** can be shorter then a loop. Makes me wonder when it's better for a given language to switch between 1 or 2 loops.

Do they have to be astricks? What about newlines?

The shortest solution in JavaScript I can come up with to print to browser in JavaScript is for(d=document.body,i=0;10>i++;d.innerHTML+='
')for(j=0;10>j++;)d.innerHTML+='*'. I'd love to post this as an answer, but for some reason this question is "protected" and I don't have enough reputation here yet to post answers to "protected" questions.

you say trailing new lines are acceptable. Are leading newlines acceptable too?

Lua: c="**********";print(c:gsub("*",c.."\n"))

Brainfuck, 47 bytes
++++++++++[->++++>+>+<<<]>++>[-<..........>>.<]

Try it online!
++++++++++[->++++>+>+<<<]   set the tape to 40 10 10
>++>                        set the tape to 42 10 10
[-<..........>>.<]          come on

+1 for emoticon in the code >.<

+1 for the fish bones >++>

C (gcc), 41 39 bytes
main(i){for(;++i<puts("**********"););}

what version of c?

@Zaibis Works fine on gcc: http://coliru.stacked-crooked.com/a/848cb22a00c35c29 .

Add this info. I got that i is undcleared ;) So I can un downvote.

looks good, good ol' ANSI C.

main(i){while(11-i++)puts("**********");} is an alternative, same length.

@YSC I saved two more bytes :)

I like the clever use of the return from puts() (and of the initial value of i).

Bash + coreutils, 19 bytes
I prefer to repeat stuff in Bash using 'yes'.
yes **********|head

I saved 2 bytes by @Neil's suggestion. But when the directory where you are running this command does not only contain files starting with a '.' dot you need to enclose the stars * with ".
Bash + coreutils, 21 bytes
yes "**********"|head

Great idea to use yes. We usually label such solutions as “Bash + coreutils”.

Nice that 10 lines coincidentally happens to be the default for head.

Can you save two bytes by requiring that any files in the current directory must begin with a .?

@Neil, is your comment ment for my answer? If so, I do not get it :)

Normally echo * expands to all the files in the current directory that don't begin with a .; if there are no such files though, the * has no effect.

I do not get it. yes just repeats the following text over and over. I do not use echo here... I just do not see what you mean.

@CousinCocaine: His point was that you can get away with not quoting the ********** command-line argument if the program is always run in a directory where no files match that pattern.

@HenningMakholm Aha! I get it! So is it 'legal' to golf the "?

You can also write yes \**********|head without the restriction on files.

@FlorianF and what if the filename starts with an *?

@CousinCocaine If a file starts with a * then it doesn't work.  :-(  So it is just a good compromise.  Having a file that starts with * is much less likely than to sit in a non-empty directory.

In programming, relying on 'less likely' is dangerous, but you are right, it also wont work with a file named **********

Vim, 13 8 bytes
Saved 5 bytes thanks to @Lynn

qqi*␛9.o␛q9@q

10i*␛Y9p

10i*␛ insert 10 times *, and Y9p copy the line and paste it 9 times.

10i*♥Y9p works.

That's insane vi.

I think you can count keystrokes instead of bytes for text editors, which means  would be shorter.

@addison <ESC> is 1 byte

Oh nevermind, I misread the answer. I see now

Why ♥ and not ␛ ?

Can you provide some explanation as to why this works? Great work (+1)

I would have used yy9p myself, but nice job using capitals to save a character!

@CL. Vim is love, Vim is life

Pyth, 6 bytes
VT*T\*

T is 10 in Pyth, Vab executes statement b a times, \* is the asterisk character constant, and multiplying (*) a string and an integer repeats that string n times. Pyth's implicit printing with V means 10 lines are printed.

Hexagony, 37 35 34 31
10"+}(=${";<$<1}42/.0@_=<>\;>(_

Expanded:
   1 0 " +
  } ( = $ {
 " ; < $ < 1
} 4 2 / . 0 @
 _ = < > \ ;
  > ( _ . .
   . . . .

Try it online
Basically just has two for loops counting down from ten to zero, printing out an asterisk on the inner loop, and a newline on the outer loop.
Explanation:
This program consists of three main parts: initialisation of memory, a loop which prints ten asterisks and a loop which prints a newline. The loop which prints a newline also contains the loop which prints the asterisks.
First, the code runs the totally linear memory initialisation. The code works out to be: 10"+}42. This sets the memory of the nearby edges to look like:
10 \ / 10
    |
   42

42 is the ASCII code for the asterisk character, and the two tens will be used as our loop counters. Of note is that the memory pointer is currently pointing away from the two tens, so moving backwards will put us on one of the tens.
Next, we start the astersisk printing loop. Linearly, the code looks like: ;".._(. This prints out an asterisk, moves the memory pointer backwards and to the left and finally decrements the value there. After one iteration, the memory would look like:
10 \ / 9
    |
   42

Then we hit the loop condition: the bottom-leftmost >. If the edge we just decremented is still positive we bounce around and execute a { to move us back onto the 42. Then we hit a $ and return to the beginning of the printing loop, the ;, by skipping the <. If the value was zero, we head into the other loop.
The outer loop begins by resetting the recently zeroed memory edge to ten (this is the 10 in the code, going southwest). Then, we print out this ten as an ASCII character, which is a newline. Next, we move onto the other memory edge and decrement it with {( and then execute what amounts to a bunch of noops: =${_=. Now, after one iteration of this loop, memory would look like:
 9 \ / 10
    |
   42

This time, the memory is facing outwards from the edge storing a nine in the above diagram. Next we execute the < which acts as the loop condition for the outer loop. If the value was non-zero we bounce around off of some mirrors, then begin executing meaningful instructions again after entering the top of the hexagon at the " moving southwest. This causes us to move backwards and to the left, onto the 42 again, but facing inwards. Then the = flips our direction, resetting the state properly to begin the inner loop again. If the edge was set to zero, the instruction pointer goes on a little adventure which does nothing until it exits the program.
The adventure begins by the instruction pointer venturing northeast, perilously disregarding the safety of the cardinal directions. It bravely ignores a mirror that is aligned with its diretion (/) and heroically leaps off of a trampoline ($) entirely evading the deadly trap of another, totally identical trampoline. Staring out at the emptiness of uninitialised hexagon edges, the pointer, without faltering for a moment, adds the two blank edges it faces together, setting the current edge to their sum: 0 (the edge was actually zero beforehand, but the pointer likes to believe this was pretty important). Since the edge is zero, the pointer makes a left turn at the fork in the road, walking into a mysterious forest (of hexagons). There, it finds itself disoriented, moving forwards and backwards and forwards, until it winds up at the same place in memory as it started. Thinking that the problem must be that the current edge was set to zero last time, the pointer bravely plants a 1 into the current edge. Then, the noble pointer investigates another path, one laid with... a trap! The current edge is decremented and set back to zero! The pointer, dazed by the shocking turn of events, stumbles back into the trap setting the current edge to negative one. Infuriated, the pointer attempts to return to the comparatively pleasant forest, only to notice that since the current edge is not positive, the paths have yet again shifted and the pointer finds itself walking into a cave. And by a cave, I mean the mouth of a giant hexagonal worm. Helpless, the pointer curses the sexinity with its dying breath. Also, the program ends.

Golly, I hope the worm was OK with swallowing a pointer. Those things can hurt.

+1 for writing the most interesting—the only—Hexagony explanation I've ever read. I felt so tense when the edge was decremented!

Emacs, 10 8 keystrokes
F3 C-1 0 * ENTER F4 C-9 F4
Explanation
F3             Starts a macro recording
C-1 0 *        Apply 10 times command '*': prints 10 asterix'
ENTER          Insert new line
F4             Stops the macro record
C-9 F4         Apply 9 times the macro

Thanks to Sean for saving two keystrokes, suggesting to replace C-udigit with C-digit.

+1, I always upvote text editor answers (even though I'm more of a vim guy myself) :)

If C-u counts as just one keystroke, then you can shave off two strokes by typing C-1 C-0 (or M-1 M-0) instead of C-u 1 0 and C-9 instead of C-u 9.

+1 because you had to suffer through using emacs to write this.

Alternatively (saves nothing) the line repetition can be done inside the macro: F3 C-1 0 * ENTER C-1 0 F4

@JonathanCarroll yes it would save bytes if we were to print more than 10 lines ;)

@DrMcMoylex Even is they're spam? (Not that this answer is, +1 for no vim)

Jelly, 7 bytes
”*x⁵Ṅ9¡

What's going on?
”*x⁵Ṅ9¡  - No arguments
”*       - character literal, *
  x      - multiply (dyadic operation)
   ⁵     - integer literal, 10 (we have now constructed the string '**********')
    Ṅ    - Print & linefeed (monadic operation)
     9   - integer literal, 9
      ¡  - Repeat n times (n is 9 as the first Ṅ is not a repeat)

Test it on tryitonline

I really like the Ṅ9¡.

List version: ”*ẋ⁵Wẋ⁵.

@EriktheGolfer you'd need a Y on the end to "print this exact text"

@JonathanAllan It is a list on its own, though. It isn't meant to "print this exact text", but, if you want to work on it, you'll use it.

PowerShell, 14 12 bytes
,('*'*10)*10

Constructs a string of asterisks of length 10 using string multiplication. Encapsulates that in parens and feeds that into the comma-operator to construct an array. We use array multiplication to construct a 10-element array consisting of that element (i.e., a 10-element array of asterisk strings). That's left on the pipeline, and output is implicit (since the default Write-Output for an array is newline-separated, we get that for free -- thanks to @Joey for the clarification).
Older, 14 bytes
0..9|%{'*'*10}

Full program. Loops from 0 to 9 through a ForEach-Object loop |%{...}. Each iteration, we use string multiplication to create a length-10 string of *. Those resulting strings are left on the pipeline, and output at the end is implicit (since the default Write-Output for an array is newline-separated, we get that for free -- thanks to @Joey for the clarification).

I like it, because powershell can get so verbose. Yet this is elegant and short.

Well, technically the array is never passed through a ToString, it's unrolled and passed element by element to Write-Output. In contexts where the array is converted to a string, you get its elements space-separated.

@Joey Ah, fair, that's a better way to put it. I'll edit the wording (and my answer template ;-)).

I may be biased here because I'm involved with a PowerShell implementation so I had to learn a lot of what actually goes on inside the interpreter ;)

V, 7 bytes
10é*10Ä

Try it online!
About as straightforward as an answer can be.
Explanation:
10      "10 times:
  é*    "insert an asterisk
    10Ä "make 10 copies of the current line

5 bytes:
10O±*

Explanation:
10O     " Insert the following on the next ten lines:
   ±    "   10 copies of
    *   "   an asterisk

This didn't work when the challenge was posted because of a bug.

Point of order: é and Ä are multibyte characters (at least in utf-8, as you have them here) so this program is 9 bytes long.

@rob They are encoded in utf-8 here, because that's just the way the browser works. V uses "Latin1" encoding, where they are E9 and C4 respectively.

Jellyfish, 12 10 bytes
Thanks to Zgarb for saving 2 bytes.
P$'*
 &;10

Try it online!
Explanation
Using more conventional notation, this program represents the following expression:
P( $( &;(10), '* ) )

&; takes a single value and creates a pair with two times that value, so &;(10) gives us [10 10]. Then $ is reshape which forms a 10x10 grid of asterisks. Finally, P prints the array in "matrix format" which prints each string on its own line.

HTML & CSS, 104 60 bytes

p::after{content:"**********"

I'm unsure if the byte count is correct (as I'm not counting the  in a totally empty file), the :after matches every element's after (in this case html and body) and * is used to remove the body margin.

Mornington Crescent, 1940 bytes
Take Northern Line to Euston
Take Victoria Line to Seven Sisters
Take Victoria Line to Euston
Take Victoria Line to Euston
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross
Take Bakerloo Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Try it online!
// "*" = 42 = 6*7

// get 7
Take Northern Line to Euston
Take Victoria Line to Seven Sisters

// copy it
Take Victoria Line to Euston
Take Victoria Line to Euston
Take Northern Line to Bank

// add it until 42
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Upminster
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster

// get char "*"
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross

// concatenate it (shorter than with loop)
Take Northern Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington

// calculate a 10 for newline
// get 5 from Heathrow Terminal 5
Take District Line to Acton Town
Take Piccadilly Line to Heathrow Terminal 5
Take Piccadilly Line to Acton Town
Take District Line to Acton Town
Take District Line to Parsons Green

// add 5 + 5
Take District Line to Bank
Take Circle Line to Hammersmith
Take District Line to Upminster
Take District Line to Hammersmith
Take District Line to Upminster

// get char "\n"
Take District Line to Bank
Take Circle Line to Bank
Take Northern Line to Charing Cross
Take Northern Line to Charing Cross

// concatenate it with asterisks
Take Bakerloo Line to Paddington

// copy them
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Paddington
Take Circle Line to Bank
Take Circle Line to Hammersmith
Take Circle Line to Paddington
Take Circle Line to Hammersmith
Take Circle Line to Paddington

// go home and print
Take Circle Line to Bank
Take Circle Line to Bank
Take Northern Line to Mornington Crescent

Flurry, 76 bytes
({<(<({})(<({}){}>){}>){}>}){(({}){(){}(((<><<>()>){})[{}{<({}){}>}])}{})}{}

Can be run with the interpreter as follows:
$ ./Flurry -bnn -c "$pgm"
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Explanation
A function that composes two functions (or multiplies two numbers):
comp = λf g x. f (g x)
     = λf g x. K f x (g x)
     = λf g x. S (K f) g x
     = λf. S (K f)
     = S ∘ K
    := <<>()>

A function that increments a number by one:
succ = λn f x. f (n f x)
     = λn f. comp f (n f)
     = λn f. S comp n f
     = S comp
    := <><<>()>

A function that computes n(n + 1):
oblong = λn. n * succ n
       = λn. comp n [succ n]
       = λn. S comp succ n
       = succ succ
      := <><<>()> [<><<>()]
      := (<><<>()>) {}

The number two:
2 = λf x. f (f x)
  = λf. <f f>
 := {<({}){}>}

The number six:
6 = 2 * 3
  = 2 * succ 2
  = oblong 2
 := oblong {<({}){}>}
 := (<><<>()>){} {<({}){}>}

The number 42 (ASCII value of *):
42 = 6 * 7
   = 6 * succ 6
   = oblong 6
   = oblong (oblong 2)
  := (oblong) [{} 2]
  := ((<><<>()>){}) [{} 2]
  := ((<><<>()>){}) [{} {<({}){}>}]

The number 10:
10 = λf x. f (f (f (f (f (f (f (f (f (f x)))))))))
   = λf. f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f ∘ f
   = λf. push (f ∘ f ∘ f ∘ f ∘ f) ∘ pop
   = λf. push (f ∘ push (f ∘ f) ∘ pop) ∘ pop
   = λf. push (push f ∘ push (push pop ∘ pop) ∘ pop) ∘ pop
  := {<  (    < ({})    (    <  ({})     {}>)   {}>)    {}>}
  := {<(<({})(<({}){}>){}>){}>}

A function that pushes 42 to the stack and returns its argument:
push_star = λx. (push 42; x)
          = λx. K x (push 42)
         := {() {} (42)}
         := {() {} (((<><<>()>){})[{}{<({}){}>}])}

A function that takes the number 10 and then pushes ten copies of 42, followed by 10, and returns 10:
push_row = λn. push (n push_star n)
        := { (({}) push_star {}) }
        := { (({}) {(){}(((<><<>()>){})[{}{<({}){}>}])} {}) }

Applying push_row 10 times to the number 10:
main () = 10 push_row 10
        = (push 10) push_row pop
       := (10) push_row {}
       := ({<(<({})(<({}){}>){}>){}>}){(({}){(){}(((<><<>()>){})[{}{<({}){}>}])}{})}{}

x86-16 machine code, IBM PC DOS, 17 bytes
00000000: b10a 8bd1 b82a 0acd 1088 c8cd 294a 75f4  .....*......)Ju.
00000010: c3                                       .

Listing:
B1 0A       MOV  CL, 10             ; repeat '*' 10 times per line
8B D1       MOV  DX, CX             ; counter for 10 line loop
        LINE_LOOP:
B8 0A2A     MOV  AX, 0A2AH          ; AL = '*', AH = 0AH
CD 10       INT  10H                ; print '*' 10 times
88 C8       MOV  AL, CL             ; AL = LF char (0xA)
CD 29       INT  29H                ; write to screen
4A          DEC  DX                 ; dec counter
75 F4       JNZ  LINE_LOOP          ; loop for 10 lines
C3          RET                     ; return to DOS

Uses PC BIOS INT 10H function 0AH (write char at current position CX number of times) for each row.  Since this function doesn't actually advance the cursor only a line feed/LF (0xA) char is needed to move to the next line.

Vyxal, jH, 6 5 4 3 bytes
×*²

Try it Online!
Explained
×*²
×*      # Push 100 asterisks onto the stack (as a single string) // the H flag initalises the stack with 100
  ²     # Split into pieces of 10 and use the j flag to join on newlines.

Alternatively:
Vyxal, 5 bytes
₁×*²⁋

Try it Online!

Perl 5, 17 bytes
say'*'x10for 0..9

Try it online!

need to print * not x

@roblogic: Thanks for your hint. It was only a small change, of course.

RAMDISP, 31 bytes.
[P[5[*2]R[M[I[;**********
]]]]]

[P - pipe through the following array
  [
    5 - 5
    [*2] - times 2 [10]
    R - create a range of that size [1..10]
    [M - for each element in that range
      [I - ignore it
        [;**********\n] - print eight asterisks and a newline
                          (real newline was replaced by \n)
      ]
    ]
  ]
]

basic, but works.

Out of interest, did you make this language?

@RedwolfPrograms yes! but i made it before i even joined stackexchange so i dont think it's cheating

It wouldn't be cheating either way! In fact, I've got a bounty of +100 reputation for new(ish) languages, and this one looks really interesting.

51AC8, 10 bytes
10[10\*×t]

Try it Online!
Explanation
10[10\*×t]
10          # Push 10 (for each loop; looping var)
   [        # Begin foreach loop (for 10 times)
    10      # Push 10
      \*    # Push '*'
        ×   # Multiply
         t  # Pop and print
          ] # End foreach

GForth 36 Bytes
: A 10 0 do ." **********" CR loop ;

05AB1E, 6 bytes
'*T×v,

Try it online!
'* character literal: "*"
T× repeat ten times as a string: "**********"
v for each character y in this string:
, print the top of stack. As the stack is empty and there is no input, this uses the value that was previously on the stack, "**********".

K (ngn/k), 16 14 13 bytes
` 0:10 10#"*"

Try it online!
Thanks to @Bubbler in the k tree for helping me out with this.
¯2 bytes thanks to @Bubbler
¯1 byte thanks to @Bubbler

Cascade, 32 27 bytes
"
*
*
*
*@
*}
*|
*/
*
*.
*/

Try it online!
Aha! It turns out just printing ten asterisks ten times does beat out my more complex answer. Unfortunately though, writing this program exposed not one, but two bugs in my interpreter. Below is my longer, but higher effort solution:
Cascade, 32 bytes
_9'2
 ^*|
\ !]
(.n
n?\
\%!|
n)+\

Try it online!
One of my more compact Cascade programs. I'm still not sure if it would be shorter to just print 10 asterisks 10 times instead of using a counter, but I'm satisfied with this, especially how the bottom intersects with the top.
Explanation
The easiest way to understand the code is know the basic structure. Each instruction can take up to three inputs, each one below it.
 +
lcr

These are the left, center and right arguments. In this case, the + instruction is dyadic, meaning it takes the left and right arguments. Most instructions are either dyadic or monadic (taking one argument, the center one). The /\| instructions take only the argument they are pointing to, and the ! instructions skips over the center and takes the argument two below it. Each of these arguments can themselves be code instructions, meaning they chain together in a prefix like notation. For example, this code could be represented by the recursive Lisp-like code:
code = (if (0==(n=dec n))
         doboth
           (print (
              if (% n (+9 2)) ('*')
              else (inc 9)
           ))
           (code)
       )

If that doesn't make sense, here's an expanded look at the code, which is still a little confusing, but it at least has an idea of which parts are connected to each other through the |/\Xs. Note that the top and bottom rows are the overlap between the two (and same with the left and right).
\  |/|\ \
 _ 9 ' 2
/ \  |  /
   ^ * |
  / \  |
 \   ! ]
\ \  \/ \
 ( . n/
 | | |
 n ? \
  /|\ \
 \ % ! |
  X \\ |
 n ) +/\
\  |/|\ \

Starting from the top left corner, we have the first check (_) which executes the right branch only if the left is successful. The left goes down to the ], which sets the n variable (initially 110) to the decrement (() of n, i.e. n=n-1. The check then takes the result of this (the new value of n) and continues if it is positive. This moves onto the branch instruction on the right (^), which executes both the left and right branches.
The left prints (.) the value given by the choice instruction (?). This branches depending on the center value, which is the modulo (%) of n and the addition (+) of 9 and 2. Note that this wraps around to the top again for those digits. If n%(9+2) is 0, then we branch left, which navigates around the % and returns the increment ()) of 9, printing a newline. If it is not divisible by 11, then we go right, skip over the + with a !, and return the character (') of * to print.
Now the right branch of the ^ skips over the n, then goes right, down, and right again, wrapping around both the right edge and the bottom edge to loop back to the _ in the top left. This now loops over the exact same code until n has reached 0, printing ten asterisks and then a newline.

Minim, 42 37 35 Bytes
New solution halts by checking if [0] > 99.
$<42._^++[0]%10.$<10._^[0]>99.C=-1.

With whitespace and comments:
$< 42.         ; Print 42 as unicode '*'
_^ ++[0] % 10. ; Increment index 0 and skip next stmt if index 0 mod 10 is nonzero
    $< 10.     ; Print 10 as unicode '\n'
_^ [0] > 99. ; Skip next stmt if index 0 is greater than 99
    C = -1.    ; Set program counter to -1 (advances to 0 afterwards)

Old solutions halted by checking [0] == 100...
$<42._^++[0]%10.$<10._^[0]==100.C=-1.

... or used labels and gotos.
_>1.$<42._^++[0]%10.$<10._<?([0]-100)._>0.

GitHub Repository

Nice answer! Did you make this language? (Also, welcome to Code Golf!)

@RedwolfPrograms Thank ya kindly~ Yes indeed! This is an old esolang (2017) that I resurrected last month, and have been in the process of finishing. I didn't do too bad for my first entry, I suppose! And thank you~

Also just realized that my program's size is the ASCII value of the asterisk! How serendipitous~

When I went to the esolangs article, I instantly recognised this as being from Truttle server. Welcome to the wonderful world of Code Golf!

Elixir, 35 bytes
for _<-0..9,do: IO.puts"**********"

Try it online!
Originally suggested to @Chester Lynn on their answer.

V (vim), -v 11 bytes
i*<esc>yl9pyy9p

Try it online!
Insert a * and copy it 9 times towards left and copy the line and paste it nine times.
Also I am a sock of someone :P
-4 as I am an idot.

Ooh nice, a fellow sockpuppet

9i*<esc>yy9p?

Also, this is 11 bytes, not 15 bytes, because <esc> is one byte

dom!!!e @pxeger

Python 3, 25 24 bytes
-1 byte thanks to @Jo King
*map(print,['*'*10]*10),

Try it online!
Unpacks the map object so it actually prints the output, instead of optimising it away.

Flobnar, 27 bytes
6v|<
+|_,
4|<v|@
7, |
*< |<

Try it online!
Same but abusing vertical if |.

Flobnar, 32 bytes
7  009
*,!__<
6 0^|<
>___,+
^!|@

Try it online!
The ultimate abuse of the behavior of _:

'Horizontal if', denoted _, checks what the cell on the other side of it evaluates to. If that value is nonzero, it evaluates to what the cell west of it evaluates to; otherwise, it evaluates to what the cell east of it evaluates to. In either case, at most two evaluations are made.

If _ is entered horizontally, it can be used to evaluate the other side twice, or various numbers of times if chained with other _s and/or horizontal arrows.
The first half (printing * 10 times) works like this:
7
*,!       Print an asterisk and return 1
6

7  00
*,!__<    Print asterisk 10 times (enter at the lower right corner):
6  ^|<

|  Check if the west returns nonzero value
^    evaluate north
_    evaluate other side, which is 0; evaluate east
_    evaluate other side:
<      evaluate west
_      evaluate other side:
_        evaluate other side:
..!        print * and return 1
         nonzero, so evaluate west
..!        print * and return 1
       nonzero, so evaluate west
_        evaluate other side: (repeat; * is printed 4 times so far)
     nonzero, so evaluate west
_      evaluate other side: (repeat; * is printed 6 times so far)
   nonzero, so evaluate north of |
_  the other side is 0, so go right to < (repeat; * is printed 10 times in total)

The other half (going through the large loop 10 times) is more straightforward, so figuring out that part is left for the exercise to the reader.

Flobnar, 40 bytes
d1_ +
@+|\<\
::
g- < >
:1 6
%9>*>
>+,7_,

Try it online!
More explicitly controlled loop. gets 100 (d) from the position (0, 0) of the grid, and repeats that many times, printing * at every iteration and a newline every 10 loops.

Knight, 14 bytes
O*+*"*"10"
"10

Try it online!
Ungolfed:
OUTPUT                    Print the string:
      * "*" 10            10 copies of "*"
    +          "\n"       newline appended
  *                 10    10 times concatenated

Nibbles, 13 12 nibbles (6.0 bytes)
^10: ^10"*" "\n"

Attempt This Online!
Explanation
^10: ^10"*" "\n"    #
----------------------------------------
     ^10"*"         # replicate 10 times
   :        "\n"    # append
^10                 # replicate 10 times

-1 Nibble thanks to xigoi

Nibbles is getting pretty competitive these days...

true... I just found an answer where someone linked ATO for Nibbles, so I just added that to my existing answers :D

You can use "\n" instead of '\n' for -1 nibble (string literals are cheaper than character literals).

///, 24 bytes
Leaky Nun's answer finally needed to be proven not golfed far enough!
/5/*****//-/55
55
/-----

Try it online!

Java,  103 Bytes    92 Bytes
class Main{public static void main(String[]a){System.out.print("**********\n".repeat(10));}}

Try it online!

Welcome to code golf, and nice first answer! You can remove the  space between String[] and args, and it’s shorter to in-line the "**********\n" string, so you can reduce this code to 95 bytes: Try it online!

Python 3, 29 23 bytes
print(('*'*10+'\n')*10)

Thanks to orlp for shaving off 6 bytes.

We require either a full program or a function. An expression is not sufficient.

Yes, I'm referring to your second paragraph.

print((10*"*"+"\n")*10) is shorter.

darnit we had the same answer :(

Changing print to exit will save 1 byte and still output the result, there wasn't specified if it should be printed on standard output.

@GáborFekete exit only works on the repl.

@orlp So how does that violate any specification?

@GáborFekete Python REPL is a different programming language. We define languages by their implementation.

Golisp, 34 bytes
for[range@10{(_)writeln@*["**"5]}]

Due to a "bug", I can't concatenate strings...

Congratulations!

@LeakyNun For what?

For developing a language.

@LeakyNun Just look at my GitHub repos...

I didn't say "for developing your first language"

C#, 79 bytes
class P{void Main(){for(int i=0;i++<10;)System.Console.Write("**********\n");}}

This won't run without static void right?

@pay has void already not sure if it needs static will check later when I have chance

golflua, 22 characters
~@i=0,9 w"**********"$

Sample run:
bash-4.3$ golflua -e '~@i=0,9 w"**********"$'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

C++, 75 bytes
#include<cstdio>
int main(){for(int i=0;i<10;++i)std::puts("**********");}

Why the downvote?

I believe this was an automatic downvote from the community user. Your post was auto-flagged as low quality (since it only contained code) and Leaky Nun's edit caused an automatic unowned downvote. See http://meta.stackexchange.com/q/236883

Got it.  Bummer.

I -1'ed it because you simply took Matthew Roh's answer and applied the suggestions from his comments. So no own effort at all!

That's actually not true.  I don't think it's fair to assume.

You can save 1 byte by changing the for-loop to: for(int i=0;++i<11;)

Use int main(i) and remove the int i=0. Then, replace i<10;++i with i++<10;. -7

S.I.L.O.S 45 bytes
All whitespace necessary due to my poor interpreter design.
a = 10
lbla
printLine **********
a - 1
if a a

Try it Online!

19 bytes off

T-SQL, 50 bytes
print replicate(replicate('*',10)+char(10),10)

not an T-SQL expert but wouldn't 'print replicate('**********'+char(10),10)' be shorter?

C, 47 bytes
main(i){while(i<111)putchar(10|!!(i++%11)<<5);}

Try it online.
Not as compact as the other C answer (putchar is such a long name!), but I don't use the asterisk character in my program. It treats the output as a 11 by 10 grid, where the 11th character is the newline. It then computes the ASCII for '*' (10 + 32 = 42) or '\n' (10) for each position.
I could save one byte with this approach if I were to change the character expression to: 42-!(i++%11)*32, but that would require an asterisk.

Notepad++, ??? keystrokes
I have no idea how to score this, but I decided to give it a shot since there's an answer on Notepad.
Here's the sequence:
* * * * * CTRL (hold) A D → D D D D D D D D D

If http://codegolf.stackexchange.com/a/88747/14732 is valid (and has upvotes), this is more than perfectly valid.

@Mego As long as that one exists, this one will exist as well

Bash (pure), 30 bytes
printf '%.s**********
' {0..9}

Test it on Ideone.
How it works
Before calling the shell built-in printf, Bash expands the glob {0..9} to 0 1 2 3 4 5 6 7 8 9.
The format string
%.s**********

specifies a string whose first 0 characters are included in the output (%.s), followed by ten asterisks and a linefeed. printf repeats the format string as many times as needed to consume all arguments. Since .%s is an empty string, this results in the desired output.

Clojure, 38 bytes
(apply print(repeat 10"**********\n"))

Simple enough

I'm afraid, that should be 38 bytes. Currently it prints only 8 x 8.

You are completely right. I keep posting wrong cases this whole day.

Underload, 22 bytes
(*****):*(
)*:*::*:**S

Brachylog v1, 15 bytes
9ye,"*":9jw@Nw\

Try it online!
Explanation
This exploits backtracking to loop; we create ten useless choice points at the beginning so that it writes ten times the string "**********\n".
9ye,         Pick a number between 0 and 9 (there are thus 10 choice points here)
"*":9j       Concatenate "*" 9 times to itself
w@Nw         Write that string and write a line break
\            False (trigger backtracking: pich another one of the ten numbers)

Xtend, 33 bytes
[for(_:0..9)print('**********
')]

... a Java dialect; [] is a lambda definition

Ruby, 26 20 bytes
10.times{puts'*'*10}

Try it online!
Explanation
Runs 10 times; each time, it prints * (10 times), with an automatic line break at the end.
Kudos to OrangeFlash81 for saving me 6 bytes.

I think 10.times{puts'*'*10} works as well and is shorter.

Scheme, 51 Bytes
(map (lambda (n)(display "**********\n"))(iota 10))

PyMin, 14 bytes / 10 characters
»("*"Ҁ+ѿ)Ҁ

Shorter version with v0.5:
13 bytes / 9 characters:
»("*"ҀƜ)Ҁ

The repository was deleted.

Deadfish ~, 24 bytes
{{iiii}ii{c}{ddd}ddc{d}}

how it works:
{foo} does foo exactly ten times.
first, it starts a ten loop, in this loop, it sets the counter to 42, prints it ten times (as char (asterisk)), decrements it to 10, prints it (newline), subtracts 10, then loops again, doing this 10 times.

23 bytes by setting the counter to 10 initially

TI-Basic, 21 bytes
For(I,0,9
Disp "**********
End

GNU sed, 27 bytes
s/^/**********/;h;H;G;H;g;G

To add to the diversity of languages used, I present a sed solution. The code works as follows, indicating the number of sets of 10 asterisks in pattern space and then in hold space:
s/^/**********/        # 10 asterisks are added to pattern space      (1 0)
h                      # overwrites hold space with pattern space     (1 1)
H                      # appends pattern space to hold space          (1 2)
G                      # appends hold space to pattern space          (3 2)
H                      #                                              (3 5)
g                      # overwrites pattern space with hold space     (5 5)
G                      # after G, pattern space is printed on exit   (10 5)

BrainFuck, 68 Bytes
++[>+++++<-]++[>>>+++++<<<-]++++++[>>+++++++<<-]>[>..........>.<<-]

BrainFuck is fun, this is me practicing my skills.

SmileBASIC, 19 bytes
?("*"*10+" "*40)*10

SB has a 50 character wide console, so printing 40 spaces after the 10 asterisks will bring the cursor to the beginning of the next line

Lua, 34 bytes
for i=1,10 do print"**********"end

Google Sheets, 31 23 bytes
Code:
In cell A1 (12 bytes):
=REPT(B1,10)

In cell B1 (11 bytes):
**********        # Contains New Line
                  # <--

Result:

Previous Attempt #1 (31 bytes):
=REPT(REPT("*",10)&CHAR(10),10)

Previous Attempt #2 (also 31 bytes):
=REPT("**********"&CHAR(10),10)

Braingolf, 18 bytes
8V9R#*[.]#
[R&!@v]

Try it online!
Explanation:
8V9R#*[.]#\n[R&!@v]
8                    Push 8
 V                   Create stack2 and switch to it
  9                  Push 9
   R                 Return to stack1
    #*               Push codepoint of *
      [.]            Do-while loop, will run 9 times due to the 8 pushed at the start
       .             Duplicate last item on stack
         #\n         Push codepoint of newline
            [R...v]  Do-while loop, uses stack2 for loop counting
                     Will run 10 times due to the 9 pushed at the start
              &!@    Print entire stack1 without popping

15 bytes

Forth (gforth), 36 34 bytes
: f 9 for ." **********" cr next ;

Try it online!
-2 bytes thanks to @bubbler
Explanation
 10 0            \ put 10 and 0 on the stack
 do              \ begin a loop from 0 to 10 (0 inclusive 10 exclusive)
 ." **********"  \ print the string literal ********** (the initial space is required because forth words are space separated, and ." is not an exception)
 cr              \ print out a new line character
 loop            \ end the loop

Using for..next loop is 2 bytes shorter: Try it online!

Javascript (REPL), 27 bytes, Old is 32 bytes. Thanks to @Peter
('**********\n').repeat(10)

Welcome to PPCG! Please note that we count REPL submissions differently from full-program solutions, so this should be marked as "Javascript (REPL)".

@Mego Thank you, I will remember this!

('**********\n').repeat(10) is shorter :)

Welcome to PPCG :) Note that this solution already exists: https://codegolf.stackexchange.com/a/88660/58974. However, you can remove the brackets around the string and use a template literal with a literal newline to save 3 bytes: https://tio.run/##y0osSyxOLsosKNHNy09J/Z@cn1ecn5Oql5OfrvE/QQsOuBL0ilILUhNLNAwNNP9r/gcA

Befunge-93 (PyFunge), 28 bytes
#<90v0-1_@#:,
#^_ >1+"*",:9`

Try it online!

Kotlin (script), 32 bytes
print("**********\n".repeat(10))

Try it online!
Run this locally as a standalone program by

installing Kotlin
saving the source to a .kts file
run with kotlinc -script myfile.kts

This does not seem to work on TIO, for whatever reason, which is why I had to include the header/footer.

You could run this as a standalone program using the -script command line switch on kotlin. This doesn't work in TIO/kotlinc though.

I wasn't aware this is possible. If you want to link the script version on TIO, you could do it this way.

{print("**********\n".repeat(10))}

Kotlin, 62 bytes
fun main(a:Array<String>){for(i in 0..9)println("**********")}

Try it online!

your golfed version 37 bytes: {for(i in 0..9)println("**********")}. -3 byte version {print("**********\n".repeat(10))} )))

Java (OpenJDK 8), 61 bytes
static{for(int i=0;i++<10;)System.out.println("**********");}

Try it online!

05AB1E, 9, 8 bytes
Tƒ,TF'*+

my first golfing answer so any tips are welcome
Try it online!

That's a grid of 10x9, not 10x10

didn't notice that, fixed it @mbomb007

Z80Golf, 14 bytes
00000000: 0a4f 3e2a 46ff 10fd 7eff 0d20 f576       .O>*F...~.. .v

Try it online!
Disassembly
start:
  ld a, (bc)  ; 0a
  ld c, a     ; 4f
loop1:
  ld a, '*'   ; 3e 2a
  ld b, (hl)  ; 46
loop2:
  rst $38     ; ff
  djnz loop2  ; 10 fd
  ld a, (hl)  ; 7e
  rst $38     ; ff
  dec c       ; 0d
  jr nz, loop1  ; 20 f5
  halt        ; 76

Golfing nested loops
Since a is the parameter to putchar, I used b and c for loop counters. The loop constructs are
  ld b, ... ; 1 or 2 bytes
loop:
  (loop content)
  djnz loop ; 2 bytes

and
  ld c, ... ; 1 or 2 bytes
loop:
  (loop content)
  dec c     ; 1 bytes
  jr nz, loop ; 2 bytes

This combination of 2-level nested loops is optimal in Z80Golf.
Reusing the first instruction as data
The first byte 0a is located at memory address $0000. Since hl is always zero in this program, we can use the one-byte instruction ld r, (hl) whenever we need the constant 0a, instead of the two-byte ld r, $0a.
In this particular challenge, the byte $0a has three uses: the outer loop, the inner loop, and the newline character. The byte as an instruction is not particularly useful, so we save two bytes here.

MathGolf, 6 bytes
⌂♀*♂/n

Try it online!
Explanation
⌂       Push "*"
 ♀*     Multiply by 100
   ♂/   Divide into chunks of 10
     n  Join with newline

With an output control flag this could be 5 bytes, but I don't have that yet.

Out of curiosity, why is there a single-byte builtin to push the * character? Or are there builtins for *, +, -, and / and some kind of eval functionality for a mathematical expression in string format?

When I made the language, I wanted one single printable character to satisfy printing challenges where any character is valid. Luckily enough, I chose the asterisk! I also have a space character as a single command.

Shakespeare Programming Language, 387 bytes
,.Ajax,.Ford,.Act I:.Scene I:.[Exeunt][Enter Ajax and Ford]Ford:You be twice the sum ofa cat twice twice the sum ofa cat a big big cat.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.Speak thy.You be twice the sum ofa cat a big big cat.Speak thy.Ajax:You be the sum ofyou a cat.Be you nicer the sum ofa cat a big big big cat?If notlet usScene I.

Try it online!

352 bytes

Stax, 4 bytes
╪n│╔

Run and debug it

Gol><>, 9 bytes
aFa:R`*|H

There is a trailing newline, but the specs say it is okay. Below is a version that doesn't have a trailing new line, but adds on 2 extra bytes.
aFaR`*a|~rH

Try it online!

R 33 bytes
cat(rep('**********',10),sep='
')

Try it online
I believe this is shorter than the other R answers on this question.

I believe this is shorter than yours, but Mamie's answer on the first page (sorted by oldest) is something like 26 bytes if the comments are to be believed.

Ah, I'd missed that one, thanks @Giuseppe.

C# (.NET Core), 53 bytes
Brand new to code golf, is this type of format allowed to be used (Usage of the header section / footer section)?

for(int i=0;i<10;i++){Console.Write("**********\n");}

Try it online!

Welcome to PPCG, and Great First Answer

You can get it down to 49 bytes by moving the i++ into the conditional expression, and moving the block body into the increment statement: for(int i=0;i++<10;Console.Write("**********\n")); (try it online)

This is not valid since it's neither a function (lambdas count) nor is it a full program. With a few adjustments though, 42

@mgthomas99 btw that's 50 bytes, and it makes no difference whether the write is inside or outside

Perl 5, 18 Bytes
say'*'x10for 1..10

Requires the -E flags, as in:
perl -E "say'*'x10for 1..10"

Keg, 10 bytes
(
|(
|\*)
)

Explanation
(\n|           Start for loop iterating 10 times
    (\n|       Start for loop iterating 10 times
        \*     Push an asterisk
          )    End loop
           \n  Push a newline

Try it online!

Apparently the final ) is not needed, only the newline in front of it. At least for the TIO version.

JAPT, 12 bytes
'*
pA)+R
VpA

Japt sets vars automatically, so '* sets U to "*"
pA)+R prints U out A(10) times. And adds a new line (+R). All this is set to V.
VpA prints V out A times
In Regular JS is
U = "*";
V = (U.p(A)) + R;
V.p(A)

MAWP, 26 bytes
%25W[25W[~67W;~1A]%25W;1A]

This was interesting.
Try it!

You have no use for the % at the start and two stack reversals, essentially leading you to  my answer https://codegolf.stackexchange.com/a/209467/92080

Really should stop spamming the stack reversal everywhere.

1+, 256 255 64 61 59 56 50 48 bytes
10
42
..(|(A|";";";";";)(A)^";^)(B|()()())(B)(B)

I'm lazy. Pushes a newline and an asterisk, then simply output them, without any tricks. No loops because creating terminating loops in 1+ is painful.
EDIT: -1 byte by reusing the constant 2.
EDIT: -191 bytes by using functions.
EDIT: -3 bytes by using another function.
EDIT: -2 bytes using one more function.
EDIT: -3 bytes.
EDIT: -6 bytes, although it probably doesn't quite follow the rules. It outputs number:  followed by the correct output, but number:  is a input prompt. If the input prompt have to be counted as output, then all answers with input is invalid as well.
This exploits a weird behaviour of the interpreter. When run in TIO with argument .input.tio, it reads from the input for the program source code and reads from the input again for the program input. So, yeah, the source code is fed into the input itself. 42 is a nope NOP because the only number literal 1+ recognises is 1. . pushes the input as an integer, which is 42.
If the character was something other than * it can be 46 bytes, by reading a character, not integer (* cannot precede the program due to the empty stack)
This will be completely valid after TwilightSparkle Edition is out. (TSE have a "-o" command line option that runs the original interpreter, except there are no prompts.)
EDIT: -2 bytes. Same trick with 10.

MAWP, 23 bytes
25W[25W[67W;1A]%52W;1A]

Try it!
Two nested loops doing almost the same thing
MAWP 2.0, 20 bytes
10[10["*":1-]`10;1-]

Try it!
Basically the same thing

INTERCAL, 197 185 bytes
DO,1<-#11DO,1SUB#1<-#172DO,1SUB#11<-#260PLEASEREADOUT,1DO,1SUB#1<-#252PLEASEREADOUT,1DOREADOUT,1DOREADOUT,1DOREADOUT,1DOREADOUT,1DOREADOUT,1DOREADOUT,1DOREADOUT,1DOREADOUT,1PLEASEGIVEUP

Try it online!
Looping is ~120 bytes longer...
Fills an array with tape instructions for one line, prints that, overwrites the first instruction with a new one relative to the new tape position, prints that nine more times.
EDIT
I used one PLEASE too much, also READ OUT and GIVE UP don't require a DO between the PLEASE and themselves, saving some bytes.

Rockstar, 53 51 41 37 35 bytes
X's10
while X
say "*"*10
let X be-1

Try it here (Code will need to be pasted in)

Add++, 22 20 bytes
+42
y:10
Fy,Fy,,h,hy

Try it online!
Somehow -2 thanks to cairdcoinheringaahing

You can remove the x from Ox as it's the active variable

And a completely different approach for 20 bytes

05AB1E, 7 bytes
'*T×TF,

Try it online!
'*T×TF,  # full program
'*T×     # push "**********"
    TF   # repeat 10 times...
      ,  # output top of stack to STDOUT
         # (implicit) exit loop

05AB1E, 7 bytes
'*т×Tä»

Try it online!
'*т×Tä»  # full program
      »  # join....
  т×     # 100...
'*       # asteriks...
     ä   # split into...
    T    # 10...
     ä   # pieces...
      »  # by newlines
         # implicit output

Marbelous, 81 bytes
@0
0A
>0\/
--
&0@1
&10B
@0&0
@1/\@2
@3@2
--/\\\..@4
>0&1&1/\&2
&2\/--@4/\s*
@3
:s*
2A
{0

Marbelous is a language based on marble machines
this program is composed of 4 subparts :
the main loop
a while loop going from 10 to 0, realease &0, and wait for &1 to be released before continuing
@0
0A
>0 \/
--
&0
&1
@0

the 11(0B) generator
a structure sending 11 (0B) to the portal @2 when the synchroniser group &0 is released
.. @1
.. 0B
.. &0
@1 /\ @2

the printer
a while loop waiting for something in @2
it then print that value minus 1 asterisk
finish by printing the ascii value of @2-1 (which is 10(\n) here) and release synchroniser &1
@3 @2
-- /\ \\ .. @4
>0 &1 &1 /\ &2
&2 \/ -- @4 /\ s*
@3

asterisk creator
board transforming the inputted marble into a 2A (ascii value of *)
:s*
2A
{0

used language built-in are :

.. is a noop
00-FF initiate a marble with this value
@n (n from 0 to Z) is a portal which teleport the marble to another portal with the same value
&n (n from 0 to Z) is a synchroniser, hold the marble until all corresponding synchroniser (same n) are full
\/ is a trash can
/\ create a duplicate passing marble to it's left and right
marbles going out of the machine from the bottom are implicitly outputed
-- is a decrement
\\ is a right deflector, the marble go right
>n (n from 0 to Z) is a conditional, if marble > n then noop else go right

boards
it also uses a board, boards are created with :name at the start of a new line with name being anything you want, they have special built-in

}n (n from 0 to Z) input argument
{n (n from 0 to Z) returned output

Boards execution pause the caller execution until finished
interpretor

vJASS (Warcraft 3), 100 76 bytes
Using //! import zinc "<code_path>" command to exclude //! zinc and //! endzinc.

library q{real w;function onInit(){for(0<=w<10){BJDebugMsg("**********");}}}

Would you mind slowing down a bit on updating your answers, maybe wait for an hour or so before doing some more? The recently active page is getting flooded with older questions because of the edits, and it'd be good to let it settle down a bit

@ChartZBelatedly oh, okay. Sorry for my unintentional spam.

No worries, just thought it'd be worth letting you know :)

Notepad++, 15 13 keystrokes
*<Ctrl-Shift-R><Ctrl-A><Ctrl-D><Ctrl-D><Ctrl-D><Ctrl-D><Ctrl-A><Ctrl-D><Ctrl-Shift-R><End><Enter><Ctrl-Shift-P>

Saved two keystrokes by using a macro. Explanation to come.
Original code and explanation
*****<Ctrl-D><Ctrl-D><Ctrl-D><Ctrl-D><Ctrl-D><Ctrl-A><Ctrl-D>→<Enter>

We start by inserting five asterisks. CtrlD duplicates this line, leaving the cursor at the end of the first line. Del removes the newline, so now we have a line of ten asterisks.
Four applications of CtrlD give us five lines of asterisks. Next, CtrlA CtrlD duplicates all five lines at once, but it doesn't include a newline between the copies:
**********
**********
**********
**********
********************
**********
**********
**********
**********

Fortunately, the first half is still selected, so if we press →, the cursor will be immediately after the tenth asterisk on the too-long line, and we can add the missing newline with Enter.

CJam, 8 bytes
'*A*N+A*

My first CJam answer!
Explanation:
'*          Push an asterisk
  A*        Multiply by 10
    N+      Add a newline
      A*    Multiply by 10
            Implicitly output

GNU nano, 14 keystrokes
<C-6>*<C-K><M-:><C-U><C-U><C-U><C-U><C-U><M-:><M-;><C-K><M-;><M-;>

<C-X> refers to CTRL+X, <M+X> refers to META+X.
Explanation
<C-6>         Start a selection block
*             Type an asterisk (typing does not affect the selection by default)
              At this point, '*' is selected.
<C-K>         Delete the selection and put it into the cutbuffer. '*'
<M-:>         Start recording a macro
  <C-U> (5x)  Paste 5 times, text is now '*****'
<M-:>         Stop macro recording. Macro pastes 5 times now.
<M-;>         Run the macro, pasting 5 more '*'s. Text is now '**********'
<C-K>         Delete the current line and put it in the cutbuffer. '**********\n'
<M-;><M-;>    Run the macro twice, pasting '**********\n' 10 times

Betcha didn't know nano had macros?
Video demo (done in Termux because of visible keyboard, --ignorerc just ignores any RC files that may alter the behavior)

Batch, 42 bytes
@for /l %%a in (1,1,10) do echo **********

Python 3, 23 bytes
print(('*'*10+'\n')*10)

Try it online!

GFortran, 31 29 bytes
print'(10A)',('*',j=0,99)
end

The loop ('*',j=0,99) spits out 100 *s. Formatting directive '(10(A))' '(10A)' wraps it.
try it online!
31 bytes

this shows that (fortran.ge.javascript)

FWIW Gnu f95 doesn't is happy with this print'(10A)',('*',j=0,99) as the print line, meaning it does the right thing with 10A instead of 10(A), which drops 2 more characters.

R, 39 bytes
cat(c("*","\n")[(0:219)%%21/10],sep='')

Don't know if R coercing indices to integer is commonly used, so thought it worth posting in case someone can do something extra with it!

Sure, navigating among so many answers is a nightmare, but different variations of doing this in R were extensively discussed here.

Fair point @KirillL. and I would have posted a comment but didn't have the reputation yet - ironically, posting the new answer has given me some of the reputation I need to do it...

CSASM v2.3.0.1, 50 bytes
func main:
push "**********\n"
push 10
mul
print
ret
end

mul duplicates a <str> value by a given <i32> amount, concatenating the copies together

Excel, 10 8 keystrokes
In a fresh empty sheet,
Ctrl+GJ10EnterCtrl+Shift+Home*Ctrl-Shift-Enter
Explanation:

Ctrl+G is a shortcut for the GoTo dialog
Entering J10 goes to that cell
Enter closes the dialog
Ctrl+Shift+Home expands the selection to A1, making a grid of 10x10 cells
Then we put in the asterisk
Ctrl+Shift+Enter (instead of plain Enter) fills in the input over all selected cells

PHP, 69 Bytes
<?for($i=1;$i<101;$i++){if($i%10!=0){echo('*');}else{echo('*
');}}

Welcome to Code Golf, and nice first answer! Be sure to check out our Tips for golfing in PHP page for ways you can golf your program

Vyxal, 8 bytes
\*₀*¶+₀*

Try it Online!
-1 due to cairdcoinheringaahing
Later I reduced another one

-1 byte

@cairdcoinheringaahing thax!

here's how to do it in 4 bytes. But I recommend you keep this because it is flagless

Flagless, ₀(\*₀*,

Barrel, 14 13 bytes
^42#10(#10p¶

Explanation:
^42          // push 42 to the accumulator
   #10       // do 10 times...
      (      // defines a code block which becomes a single instruction
             // (the parenthesis is self-closing)
       #10p  // print the accumulator as an ASCII character 10 times
           ¶ // print a newline

EDIT: removed the closing parenthesis, saving 1 byte, since I found the reason hadn't been able to get it to work right (I had added a newline at the end of my test file! *sigh*).

Yggdrasil, 105 bytes
;*
""""""""":""""""""":""""""""":""""""""":""""""""":""""""""":""""""""":""""""""":""""""""":""""""""""

Try it online!
The first few characters set up the memory tree for the program:
   ;
  / \
 *  \n

Yggdrasil has the = command for loops, but it unfortunately doesn't work. The only looping it can do is recursively call itself until it hits the recursion limit, so we have to print everything manually. The " command prints the left branch, which is *, and the : command prints both the left and the right branches, which are *\n

Deorst, 17 bytes
la
!o*
ERj
E;la
*

Try it online!
Explanation:
la    # Push 10
!     # For each 1..10:
 o*   #   Push '*'
ER    # Reverse stack
  j   # Convert 10 to char (\n)
E;    # Concatenate stack
  la  # Push 10
*     # Multiply

Rattle, 13 bytes
*|![[b]10B]10

Try it Online!
Explanation
*|                    take "*" as a variable
  !                   disable implicit output
   [ ......... ]10    loop 10 times
    [ ... ]10         loop 10 times
       b              concatenate "*" to buffer
             B        print and reset buffer

Vyxal j, 8 7 5 bytes
-1 byte cause map lambdas are awesome.
-2 bytes thanks to the j flag
My first attempt at Vyxal.
\*₁*²

Explanation
\*         - Push "*"
  ₁*       - Repeat 100 times
    ²      - Format as a square
<flag>     - Join by newline
<implicit> - Print it

Try it Online!

INTERCAL, 109 bytes
Wait, no, I don't even need to make a loop.
PLEASE,1<-#11DO,1SUB#1<-#172DO,1SUB#11<-#260PLEASEREADOUT,1DO,1SUB#1<-#252DOREADOUT,1+,1+,1+,1+,1+,1+,1+,1+,1

Try it online!
INTERCAL, 116 bytes
mindoverflow said as if they can't loop shorter, but actually you can.
The code below uses .1 as loop counter.
Starting with .1<-512,
iteration is done with DOCOMEFROM.1~.1 and (1)DO.1<-.1~#1022.
PLEASE,1<-#11DO,1SUB#1<-#172DO,1SUB#11<-#260DO.1<-#512DOCOMEFROM.1~.1PLEASEREADOUT,1DO,1SUB#1<-#252(1)DO.1<-.1~#1022

Try it online!

CLC-INTERCAL, 114 bytes.
From this how should I golf off....
DO;1<-#1DO;1SUB#1<-#121DO,1<-#1DO.1<-#512DOCOMEFROM.1~.1DOREADOUT;1+;1+;1+;1+;1+;1+;1+;1+;1+;1+,1(1)DO.1<-.1~#1022

Copy and paste to try it online!

No, I can't. Though I could do double-loops with DOSTASH.1DO.1<-#0 and DORETRIEVE.1, DOREADOUT, ~#1022, and some similar code appears twice, which makes it longer.

Subleq (8 bit), 18 bytes
 2 -1 42
 1 17  0
15 -1 -9
15 17 12
 1  8  0
10 10 -9

Explanation
 2 -1 42 Print [2]                               // [2] = 42, ASCII(42) = "*"
 1 17  0 [17] = [17] - [1]  if [17] <= 0 goto 0  // Loop 10 times
15 -1 -9 Print [15]                              // [15] = 10 ASCII(10) = <line feed>
15 17 12 [17] = [17] - [15] if [17] <= 0 goto 12 // Set [17] back to -9
 1  8  0 [8]  = [8]  - [1]  if [8]  <= 0 goto 0  // Loop 10 times
10 10 -9 [10] = [10] - [10] if [10] <= 0 Exit    // Exit program

APOL, 23 bytes
*(+(*("*" 10) "\n") 10)

tinylisp, 49 bytes
(load library
(join(repeat-val(q **********)10)nl

Try it online!

Regenerate, 13 bytes
(\*{10}
){10}

Attempt This Online!
Explanation
(\*{10}\n){10}
 \*             Literal asterisk
   {10}         Repeated 10 times
       \n       Followed by a newline
(        )      All of that
          {10}  Repeated 10 times

BQN (CBQN), 14 bytes
•Out˘10‿10⥊"*"

Attempt This Online!
Explanation
•Out˘10‿10⥊"*"
            "*"  String (1-dimensional character array) containing an asterisk
     10‿10⥊     Reshape into a 10 by 10 array of asterisks
    ˘            For each row:
•Out               Print with a trailing newline

Vyxal, 4 bytes
₀₀×ŀ

Try it Online!
   ŀ # Make a grid of size
₀    # Ten
 ₀   # By ten
  ×  # Filled with asterisks

https://vyxal.pythonanywhere.com/?v=2&c=1#WyJDSD0iLCIiLCLDlyrCsiIsIiIsIiJd 2.5 bytes

Brachylog, 11 bytes
"*"j₁₀ẉ₂ⁱ¹⁰

Try it online!
Explanation
"*"j₁₀ẉ₂ⁱ¹⁰
"*"          Asterisk
   j₁₀       Join 10 copies together into one string
        ⁱ¹⁰  Repeat 10 times:
      ẉ₂      Write (with trailing newline; predicate output = input)

Alternately, it's possible to port Fatalize's Brachylog v1 solution in 11 bytes:
Ḋ≜∧"*"j₁₀ẉ⊥
Ḋ≜            Pick some number 0 to 9
  ∧           Its value doesn't matter, it just matters that we picked it
    "*"       Asterisk
       j₁₀    Join 10 copies together into one string
          ẉ   Write (with trailing newline)
           ⊥  Force backtracking

TypeScript's Type System, 71 bytes
type F=A extends{length:10}?A:F<[...A,"**********"]>;

Try it at the TypeScript playground!
Just barely longer than Java :)
Type F recursively appends "**********" to array A until A's length is 10.

If you need the output to be a string and not a list of lines, here's an 83 byte version:
//@ts-ignore
type F=A extends{length:10}?S:F<[...A,1],`${S}
**********`>

Try it at the TypeScript playground!
This one recursively appends "\n**********" to string S while appending 1 to array A until A's length is 10. We need to do it like this because you can't get the length of a string in TypeScript's type system without converting it to a list first, so it's shorter to have a list just to keep track of iteration.
The //@ts-ignore is necessary because the compiler doesn't want to spread A, which it can't tell is a list, or inject S, which it can't tell is a string, into the main string. We could explicitly tell the compiler that A extends{}[] (A is a list of something) and that S extends string, but that comes out to be a lot longer than just ignoring the errors.

Racket, 52 bytes
(display(string-join(make-list 10"**********")"\n"))

If you're fine with just returning the string and not printing it, you can forego the (display) for a score of 41 bytes.
An alternate answer (longer at 73 bytes, but I like it better personally):
(display(build-string 110(λ(n)(if(eq?(remainder n 10)0)#\newline #\*))))

Batch, 41 bytes
@for /l %%i in (0,1,9)do @echo **********

You can shave off 1 byte by removing the first @

@SomethingDark But then it would print for /l %%i in (0,1,9)do @echo **********...

It didn't when I tested it

@SomethingDark You mean as an immediate command? As it's a single line, you might be on to something there.

As both an immediate command (in which case you could save an additional byte by using %i instead, but I need to double-check the rules for this language) and in a script.

@SomethingDark It definitely echoes the command back to me when it's in a script.

Hmm, so it does.Not sure what I was doing before.

@SomethingDark I don't think an immediate command would be allowed as it counts as a REPL environment (which is slightly different from the environment of a batch script).

Pyke, 6 bytes
TVT\**

Try it here!
       - (T = 10)
TV     - repeat(10):
  T\** -  10*"*"

Frink, 40 39 Bytes
for r=0 to 9
  println[repeat["*",10]]

-1 Byte @LeakNun

You can probably use 0 to 9

BASH, 46 bytes
for((n=0;n<10;n++));do echo "**********"; done

Or for n in {0..9};{ echo "**********";}

Or seq -f%10g 10|tr -c \\n \* in Bash + coreutils.

Maple 30 bytes
printf(cat("**********\n"$10))

C, 84 bytes
#include<stdio>
int main(){int i;for(i=0;i<10;i++){printf("**********\n");return 0;}

If anyone can improve the answer, I'd appreciate it. I'm not trying to compete, it's just been simply ages since I've coded C or C++ and this challenge looked fun.

See http://codegolf.stackexchange.com/a/88695/11259

C function without a return? that's a paddlin'. But thanks, I didn't see that answer before so I'm going to study it now.

Sprects, 22 bytes
#eeep#eppp#pqqq*
#q***

Note: The interpreter uses U+0020 instead of U+0010.

EXCEL, 26 bytes.
=REPT("**********[ae]",10)

Can go into any cell.

What is [ae]? Is that Alt+Enter (the means to input a line break in Excel)? You can include the line break in the code here. It would be 23 bytes total.

tinyAll, 17 bytes
The current version (untouched for a LONG time), is extremelly broken, but works enough for this challenge.
P'*Ra_P"
[:;]"R9_

Basically:

Pass * to the R(repeat) function
Repeat it a (10) times
Output it (_)
Pass the output (;), through string interpolation, prefixed by a newline
To the R function
And repeat 9 more times
And display the result

A boring alternative, with the same byte count:
P"**********
"Ra_

Translating:

Pass "**********
 (newline)
To the R function, to repeat a (10) times
And output the result (_)

Try it:

// Commit https://github.com/ismael-miguel/tinyall/commit/2589837678f4b6556d1bd22f163255e2e058808e#diff-65af36bb0dc600cbc7a54816dcda57fd
(function(window, undefined) {
 var funcs = {
  //echo
  '_':function(value, data){
   var tmp = data.out + (value === undefined ? data.last : value);
   data.vars[';'] = data.out = tmp;
   return tmp;
  },
  //array
  A:function(value, data){
   var split_value = (value || '').split(/(\-?\d+(?:\.\d*)?(?:[eE][\-+]?\d+)?|'(?:\\'|[^']*)*'),?/);
   var final_value = [];
   for(var i = 0, l = split_value.length; i<l; i++)
   {
    if(split_value[i][0] == '\'')
    {
     final_value[final_value.length] = split_value[i].replace(/^'(.*)'$/,'$1').replace(/\\'/g,'\'');
    }
    else if(split_value[i]/1 || split_value[i] == '0')
    {
     final_value[final_value.length] = +split_value[i];
    }
   }

   return final_value;
  },
  //comparison functions
  C:function(value, data){

  },
  D:function(value, data){

   var debug = {
    value: value,
    type: typeof value,
    memory: data
   }

   if(console && console.log)
   {
    console.log(debug);
   }

   return value;
  },
  //eval
  E:function(value, data){
   run_code(value, data);
  },
  //flip the value around
  F:function(value, data){
   if(('object' === typeof value) && value.reverse)
   {
    return value.reverse();
   }
   else
   {
    return value.toString().split('').reverse().join('');
   }
  },
  //hello worlds
  H:function(value) {
   return 'hH'[value&1]
    +'ello'
    +(value&2?',':'')
    +' '
    +('wW'[+!!(value&4)])
    +'orld'
    +(value&8?'!':'')
    +(value&16?'\n':'');
  },
  //math functions
  M:function(value, data){

  },
  //not (inverts values/casing)
  N:function(value) {
   switch(typeof value)
   {
    case 'boolean':
     return !value;
    case 'number':
     return -value;
    case 'string':
     var tmp = '';
     for(var i = 0, l = value.length; i < l; i++)
     {
      if(value[i] >= 'a' && value[i] <= 'z')
      {
       tmp += String.fromCharCode(value.charCodeAt(i) - 32);
      }
      else if(value[i] >= 'A' && value[i] <= 'Z')
      {
       tmp += String.fromCharCode(value.charCodeAt(i) + 32);
      }
      else
      {
       tmp += value[i];
      }
     }
     return tmp;
    default:
     return 0;
   }
  },
  //passthrough
  P:function(value) {
   return value;
  },
  //repeat
  R:function(value, data){
   var tmp = '';

   if(value > 0)
   {
    while(value--)
    {
     tmp += data.last;
    }
   }

   return tmp;
  },
  //string functions
  S:function(value, data){
   var methods = {
    t:function(value){
     return value.replace(/^\s+/,'').replace(/\s+$/,'');
    },
    u:function(value){
     return value.toUpperCase();
    },
    T:function(value ){

    },
    R:function(value){

    }
   };

   var tmp = data.last.toString();
   for(var i = 0, l = value.length; i < l; i++)
   {
    tmp = value[i] in methods ? methods[value[i]](tmp, value, i) : '';
   }

   return tmp;
  },
  //clears output
  Z:function(value, data) {
   return data.vars[';'] = data.out = 0;
  }
 };

 var expand_string = function(value, data){

  return value.replace(
   /\[:(?:([A-Z_])(.)?|([^A-Z_'"]))\]/g,
   function(_, func, arg, value){
    if(func)
    {
     return funcs[func](get_value(arg, data, true), data);
    }
    else
    {
     return get_value(value, data, true);
    }
   }
  );

 };

 var get_value = function(value, data, recursion) {

  if(value === null || value === undefined || value === ' ')
  {
   return undefined;
  }

  var x = (value || '').toString();

  if(/^\-?\d+(?:\.\d*)?(?:[eE][\-+]?\d+)?$/.test(x))
  {
   //returns a number
   return +x;
  }
  else if(/^[a-z]$/.test(x))
  {
   //returns a number between 10-43
   return (x in data.vars) ? data.vars[x] : x.charCodeAt(0) - 87;
  }
  else if(x[0] == '\'')
  {
   return x[1];
  }
  else if(x[0] == '"' && x.length >= 2)
  {
   var sub = x.substr(1, x.length - 2);

   return recursion ? sub : expand_string(sub, data);
  }
  else
  {
   return data.vars[x];
  }
 };

 var run_code = function(code, memory){

  if(!code || /^[a-z\d]$/.test(code))
  {
   memory.out = funcs.H(get_value(code, memory));
  }
  else
  {
   code.toString().replace(
    // /(?:([^A-Z_:'"])=)?([A-Z_])(?::('.|"[^"]*"|-?\d+|.))?/g,
    /(?:([^A-Z_'"])=)?([A-Z_])(?:('.|"[^"]*"|-?\d+|[^A-Z_'"]))?/g,
    function(_, name, func, value){

     memory.vars[name || ':'] = memory.last = (funcs[func] || noop)( value ? get_value(value, memory) : memory.last, memory);

     return '';
    }
   );
  }
 }

 var noop = function(){};

 window.tinyAll=function(code, input) {
  var data = {
   out: '',
   last: 0,
   input: input || 0,
   vars: {
    //version
    '|':'0.3',
    //input
    ':':input || 0,
    //output
    ';':0,
    //code
    '.':(code || '').toString()
   }
  };

  run_code(data.vars['.'], data);

  return data.out || 0;
 };
})(Function('return this')());

//RUN THE CODE!!!
//\n instead of a real newline, but works the same
console.log(tinyAll('P\'*Ra_P"\n[:;]"R9_'));
console.log(tinyAll('P"**********\n"Ra_'));

JAISBaL 3.0.1, 9 bytes
h**A10«

Verbose:
# \# enable verbose parsing #\
ten            \# [0] push ten onto the stack #\
push1 *        \# [1] push * onto the stack #\
mul            \# [2] multiply the top two values of the stack #\
dupmany 10     \# [3] duplicate the top value of the stack 10 times #\
popoutallln    \# [4] pop off every value in the stack and print each one with a new line #\

Conventional 10 byte version (using actual for loops):
˖˖S*˄P

Verbose:
# \# enable verbose parsing #\
ten                 \# [0] push ten onto the stack #\
for                 \# [1] start for loop #\
    ten             \# [2] push ten onto the stack #\
    for             \# [3] start for loop #\
        print1 *    \# [4] print * #\
    end             \# [5] end current language construct #\
    ln              \# [6] print a new line #\

intepreter

PostgreSQL, 39 bytes
select repeat('**********'||chr(13),10)

99, 137 bytes
99999 9 9
9999 99999 9
999 99 9
999999 99 9

99 99 9 99 9 99 9 99 9999
99
99
99
99
99
99
99
99
99
99
999999
999 999 9
 99 999
 9 99999

Try it online!

jq, 24 18 characters
(16 characters code + 2 characters command line option.)
range(10)|"*"*10

Thanks to:

Leaky Nun for suggesting to use string multiplication (-6 characters)

Sample run:
bash-4.3$ jq -nr 'range(10)|"*"*10'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

On-line test (Passing -r through URL is not supported – check Raw Output yourself.)

range(10)|"*"*10

Thank you, @LeakyNun. No idea why I left with the idea that string*number not works. (array*string is the one that not works.)

C#, 52 50 49 bytes
49 bytes : 'for(int i=0;i++<10;)Console.Write("**********\n")' (Thanks to Csharpie)
50 bytes : for(int i=0;i<10;i++)Console.Write("**********\n")
52 bytes : for(int i=0;i<10;i++)Console.WriteLine("**********")
Close with 70 bytes : Console.WriteLine(String.Concat(Enumerable.Repeat("**********\n",10)))
edit : Test here : Online C# Interactive compiler.
P.S : C# Interactive is there in Visual Studio/Roslyn for a long time, no one said the answer needs to compile into an executable, or that C# is limited to .NET's verbose BCL functions or that C# is limited to Windows.
csi.exe would just be same in functionality as other (interpreted) languages' interpreters do (like PowerShell), which is the beauty of C#.

You might want to include a link to an online interpretter/compiler so we can test your code.  e.g.

This would work almost the same as csi.exe included in Roslyn, although the behavior might not be the same for all cases.

You can shorten it down a bit for(int i=0;i<10;i++)  can be written as for(int i=0;i++<10;)

Go, 84 characters
package main;import"fmt";func main(){for j:=0;j<10;j++{fmt.Println("**********");}}

Sample run:
bash$ go build && ./golf
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Print ten asterisks without using a loop

removed inner loop per @LeakyNun

Haskell, 34 bytes
putStr$[0..9]>>([0..9]>>"*")++"\n"

λ> putStr$[0..9]>>([0..9]>>"*")++"\n"
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Since the question stipulates you have to print the text your likely need a main=.  I'd also point out that "*********\n" is shorter than ([0..9]>>"*")++"\n".

@CatWizard No need for main. Your proposal is already taken.

@CatWizard I am running GHCi on my terminal. Isn't that allowed?

GHCi is allowed.  It is generally considered a different language from Haskell.  If other people are not using main and no one has done anything I think you will fine though.

@CatWizard I added a demo so that readers know this is to be used in an interpreter.

MarioLANG, 101 99 95 bytes
Saved 2 bytes thanks to Martin Ender.
Try it Online!
+
++++)+<......(<
++====".======"
+>)+(()>...(.
+====(-=====) -
+++++[!))++ )[!
======#=======#

The left half sets the tape to 10 40 10
The second half increases the 40 to 42, then prints the 42 (*) 10 times, and a newline, and repeats that 10 times.

Link? – – – – –

@LeakyNun Sorry I completely forgot. Edited it in.

Vitsy, 13 bytes
I'm late to the party. :c
a\[aa\['*']Z]

Try it online!

PHP 46 bytes
<?php
for($i=-2;++$i<9;)echo "**********\n";?>

I think this don't needs explanation.

Swift, 35 Bytes
for _ in 0...9{print("**********")}

Gibberish, 29 bytes
56ea1[[**********]eo1su1fu]gw

Explanation:
56ea1[[**********]eo1su1fu]gw |
56                            | push 5 and 6
  e                           | switch to first instruction set
   a                          | add a, b
    1                         | push 1
     [[**********]eo1su1fu]   | push string
                           g  | switch to set 3
                            w | while a is 1 execute string as code
      [**********]            | push ten asterisks
                  e           | switch to set 1
                   o          | print a
                    1s        | subtract one
                      u       | duplicate a
                       1      | push 1
                        f     | switch to set 2
                         u    | pop a, b push 1 if a > b else push 0

Neoscript, 39 bytes
each _=0:[]:9console:log("**********");

VBA, 31 bytes
for i=0to 9:?"**********":next

in the VBA Immediate window. I couldn't find any byte-saving tricks beyond this. My best non-loop version was 45 bytes:
?replace("..........",".","**********"&vblf)

Fortran, 68 51 49 bytes
Skimmed off 17 bytes, because who needs indents and spaces?
-2 bytes thanks to @Joffan
As a tribute to senior and the fact there was no Fortran answer yet. Well, now I know why: this is a pretty hard language to golf! Just one or two indents already take up more bytes than the shortest answer here :)).
program T
do i=0,9
print*,('*',j=0,9)
end do
end

Try it! (ideone)
I tried golfing it down by introducing a nested 'implied' do loop, but the newline character wasn't available until Fortran 2003. Also, it's insanely verbose...

Loops using 0,9 limits skim off another couple? And make the positive case for not using '**********' :-)

Thanks! Not sure how I didn't think of that. Must've had a temporary brain meltdown :/

@MH. I know I'm late, but program T print'(10(A))',('*',j=0,99) end is 41 bytes long and doesn't print a leading space :-)

Oracle SQL 11.2, 44 bytes
SELECT'**********'FROM v$bh WHERE rownum<11;

Grocery List, 72 bytes
G

number ten
v
z
v
P
s
u
c
l
number ten
l
b
c
p
u
n
s
e
x
u
c
p
b
n
s
e
Try it online

LaTeX, 122 110 105 bytes
-12 bytes thanks to @Leaky Nun
-5 bytes by changing package & document type
Or, if I'm allowed to skip the document class definition & setup, and just count the package import and for-loop code: 55 bytes.
I still need to check if there's another package that has a shorter loop syntax, but for now, this simply uses pgffor (from tikz) and a foreach:
\documentclass{book}\usepackage{tikz}\begin{document}\foreach\n in{0,...,9}{**********\par}\end{document}

Ungolfed:
\documentclass{book}
\usepackage{tikz}
\begin{document}
\foreach\n in{0,...,9}{**********\par}
\end{document}

Output (w/ free page number :) ):

********** is shorter than \foreach\n in{0,...,9}{*}

Good point! Not sure how I missed that... Must've been too focused on getting the nested loop going :) Thanks!

\\ is shorter than \par

True, but then the result is no longer a proper grid as the first line will be indented.

@MH. -- Here's a Link to the Plain TeX solution:
https://www.overleaf.com/read/tpjsnrgsnnsb

There's still some room for improvement... This LaTeX version is a little shorter: \documentclass{cd}\document\def~{**********\par}~~~~~~~~~~\stop uses only 63 bytes. (IMHO: The code should be at most 109 bytes long because... you know, I mean, ... 100 times the * character and nine line breaks... Your version compresses that by 4 bytes which is fine ... )

Convex, 10 bytes
A'**{A*N}%

Try it online!

GolfScript, 27 bytes
0{"**********\n"\1+.10<}do;

Try it online!
Explanation
0              # Push 0 onto the stack: counter
{
"**********\n" # Push 10 '*' and a newline character
\              # Moves the counter onto the stack
1+             # Increments the counter
.10<           # Check if it's smaller than 10
}do;           # Repeat until counter equals 10

You know, you can just do this

I'm a newbie, I didn't know, thank you!

Another byte saved

12 bytes now

Wow, I still have a lot to learn.

@LeakyNun You don't need the [.

@Dennis Wow, I still have a lot to learn.

Thue, 30 bytes
%::=~**********
::=
%%%%%%%%%%

Try it online!

Thue, 53 bytes
%::=,*,*
>*::=>[
>,::=>]]
[::=~
]::=~*****
::=
>%%%%%

Uses the convention that "when a string is sent to the output stream, no newline is printed at the end, except if the string is empty, in which case a newline is all that is printed." This is not followed by the TIO interpreter.

S.I.L.O.S, 41 bytes
Never used S.I.L.O.S before, can probably be golfed more.
EDIT: Looks like there was already a S.I.L.O.S answer, but it didn't show up on the leaderboard. But I'll keep this answer because it's shorter.
a=10
lblb
printLine **********
a-1
if a b

Try it online!

Tcl, 25 bytes
time {puts **********} 10

Try it online!

Carrot, 10 9 bytes
*^*9^
^*9

Try it online! (copy & paste only)
*^                //pushes "*" to the stack
*9                //add 9 more copies of itself
                  //stack = "**********"
^\n^              //append a newline to it
*9                //add 9 more copies of the resulting string
                  //implicit output

Why is this non-competing?

@TheFifthMarshal Looking at the github repo it appears this program didn't work in the version of the language at the time of the challenge. I edited it anyway.

Japt, 9 bytes
Ao ç*pA)·

Test it online! This is, in fact, competing.
How it works
Ao ç*pA)·  // Implicit: A = 10
Ao         // Create the range [0..10).
   ç*pA)   // Fill with "*".repeat(A).
        ·  // Join with newlines. Implicitly print.

Can be 7 bytes these days!

tinylisp, 58 bytes
(d A(q((n *)(i n(i(disp *)0(A(s n 1)*))*
(A 9(q **********

Try it online!
We define a function A with two parameters: n is the number of iterations, and * is a row of asterisks (it will always be ten of them, but it saves bytes to pass that as an argument). If n is truthy (nonzero), we display the asterisk row (with trailing newline) and recurse with n minus 1. If n is falsey (zero), we simply return the asterisk row.
Calling the function with n = 9 results in 9 disp calls; the return value of the function is then displayed, giving us our 10th row.

remove 4 closing parens for 58?

Sure. They were needed when this answer was first written: back then, parens only autocompleted at the end of the program.

i see. interesting

Sinclair ZX81/Timex TS1000/1500
Simple enough I think
Method 1, 55 bytes (listing):
 1 LET A=0
 2 PRINT "**********"
 3 LET A=A+1
 4 GOTO 2+((A=9)*3)

Method 2, 30 bytes (listing)
 1 FOR I=0 TO 9
 2 PRINT "**********"
 3 NEXT I

The ZX81 has a 1-byte ** (which is shift and H); this will save 5 bytes from each listing and might even be a bit quicker. ** is used for to the power of.

Syms 1.3, 17 bytes (noncompeting)
{*}10;*{
}~+10;*>

Explanation:
{*}10;*{\n}~+10;*>
{*}                 Pushes "*"
   10;*             Repeats it 10 times.
       {\n}         Pushes \n.
           ~+       Adds it to the end of "*"*10.
             10;*   Repeats it 10 times.
                 >  Outputs.

2 bytes can be saved with 1.4's single char string $.

R 34 bytes
While not being elegant at all, it makes what expected in not that many bytes...
cat(rep("**********",10),sep="\n")

write(matrix('*',10,10),'',10,,'') is the same number of bytes with a slightly different approach.

MATLAB / Octave, 23 bytes
Code:
m=[eye(10) ''];m(:)='*'

Try It Online!
Result:
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

You can replace '*' by 42 to save a byte. Or use [ones(10)+41 '']

LibreLogo, 21 bytes
Code:
print(9*'*'+'*\n')*10

Result:

05AB1E, 7 bytes
'*т×Tô»

Try it online!
An alternate solution to the 05AB1E one already provided.
Explanation:
'*т×Tô»
'*      Push an asterisk
  т×    Repeat the asterisk 100 times: "***********..."
    Tô  Split it into pieces of 10.
      » Join with newlines.
        Implicit print.

q/kdb+, 19 13 bytes
Solution:
-1(2#10)#"*";

Example:
q)-1(2#10)#"*";
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Explanation:
-1(2#10)#"*"; / solution
         "*"  / the asterisk
        #     / take or reshape
  (2#10)      / list (10;10), 10 rows, 10 columns
-1           ; / print to stdout

Check, 15 bytes
"*">10:r*R]+R*o

Pushes the string * and repeats it ten times, while also storing 10 in the register. Then adds 10 to the end of the string (a newline), then repeats the whole thing 10 times.

Triangular , 28 bytes
A\(A@1].p-p..pA@...](/*76-1<

Try it online!
Expanded version:
       A
      \ (
     A @ 1
    ] . p -
   p . . p A
  @ . . . ] (
 / * 7 6 - 1 <

Commands executed, excluding directional commands:
A(1-A(1-67*@p]A@pp]

How does this work?

Perl 5, 66 bytes
$x = 1x10;$x =~ s/\d/*/g;for($i = 1; $i <=10; $i++){print "$x\n";}

Try it online!

You can remove literally all the whitespace

Excel VBA, 11 Bytes
Anonymous VBE immediate window function that outputs a 10x10 grid of * to the ActiveSheet object
[A1:J10]="*

Pyth, 6 bytes
Bet there's going to be a shorter Charcoal answer
VT*T"*

Explanation:
VT     Ten times
 *T"*  Output ten asterisks followed by a newline

Try it online!

---nope :|--- yep

@ASCII-only why am i alive

Kotlin, 41 bytes
Submission
fun f()=(0..9).map{println("**********")}

Test
fun f()=(0..9).map{println("**********")}

fun main(args: Array<String>) {
  f()
}

TryItOnline
Link

I believe lambda body is enough - 33 bytes

R: 33 bytes
write.matrix(matrix("*",10,10))

This does assume that you've loaded the MASS library.

Powershell, 78 bytes
$h=@();$v=@();1..10|% $_{$h+="*"};$i=0;Do{$v+=$h-join'';$i++}while($i-ne10);$v

Code explode:
$numbers = 1..10
$horArray = @()
$verArray = @()

Foreach ($number in $numbers){
    $horArray += "*"
}

$i = 0
Do {
    $verArray += $horArray -join ''
    $i++
}
while ($i -ne 10)
$verArray

Java 8, 73 62 bytes
o is a String passed to a Consumer
o->System.out.print("**********".replace("*", "**********\n"))

o->System.out.print("**********".replace("*", "**********\n"))

Befunge, 33 bytes
55+:v
_v#:<,"*"-1
^_1-:!#@_55+:,1

Try It Online
How it works
55+:v
....<... Initialises the stack with two 10s as counters.
........ The first is for the outer loop, and the second is the inner

.....
_v#:<... Checks whether the inner counter is 0
._......

.....           If so, decrement the outer counter
_..........       If the outer counter is 0, exit the program
^_1-:!#@_55+:,1   Else print a newline and reset the outer loop counter

.....
.....,"*"-1 Else, decrement the inner counter and print an *
........... And run the inner loop again

Befunge-98, 19 15 bytes
a1_@#:-,ka:k8*'

Try It Online
First time using 98 instead of 93. Both the k and ' commands are immensely useful.

Symbolic Python, 41 bytes
_=-~(_==_)
_=_**-~_+_
_=("*"*_+"""
""")*_

Try it online!
Explanation

_=-~(_==_) sets the value of _ to True, which is interchangeable with 1
_=_**-~_+_ performs 2**3+2, resulting in 10, and stores this in _
"*"*_ constructs a row, and +"""\n""" appends a newline.
This is multiplied by _, 10, to create the square.
At the end of execution, the value left in _ is printed.

Canvas, 5 bytes
*Ａ×Ａ＊

Try it online!
With notes (not valid code, as Canvas does not support comments):
          Print the following (implicit)
*         The string "*"
 Ａ×      Duplicated 10 times horizontally
    Ａ＊  Duplicated 10 times vertically

Julia, 23 bytes
print(("*"^10*"\n")^10)

Explanation:
print(                ) # Print
      (           )     # A string consisting of
       "*"^10           # "*" duplicated 10 times
             *"\n"      # then concatenated to a newline
                   ^10  # which is then duplicated 10 times

Io, 32 bytes
10repeat("*"repeated(10)println)

Try it online!

Japt -R, 5 bytes
AÆAî*

Test it

Japt -R, 5 bytes
AÆAç*

Try it online!
Unpacked & How it works
Ao@Aç*

Ao@    Map range(10) with a function that returns...
Aç*      "*" repeated 10 times.
       `-R` flag joins the result array with "\n"
       Implicit output

Q'Nial7, 15 bytes
10 10reshape'*'               #create atom '*', reshape to 10 by 10 matrix

Python 2, 20 bytes
print("*"*10+"\n")*10

I didn't know you could remove the space between print and the string.

Python 3, 23 bytes
print(("*"*10+"\n")*10)

Felt like entering a Python 3 program too.

Matlab, 17 bytes
@()repmat('*',10)

Try it Online

MBASIC, 32 bytes
1 WIDTH 10:PRINT STRING$(100,42)

RUN
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

No loop. Just printing 100 asterisks into a 10 character wide terminal to force line wraps.
There's no MBASIC on TIO, so I've linked the reference manual.

ORK, 185 bytes
When this program starts:
I have a scribe called W
W is to write "**********\n**********\n**********\n**********\n**********\n**********\n**********\n**********\n**********\n**********"

Try it online!
ORK does everything (even I/O and basic math) with objects. As far as this question goes, looping does not have to be one of them.

q, 12 bytes
10 10#get"*" / a 10x10 matrix

10 10#(*) should have the same effect. But I'm not sure if spaces are allowed between asterisks.

Premier, 8 bytes
'*U*N+U*

Try it online!
The boring way.
Explanation
'*U*N+U*     full program
'*           push "*"
  U          push 10
   *         repeat
    N+       append newline
      U      push 10
       *     repeat

Premier, 14 bytes
QnN
**********

Try it online! This second approach uses Premier's implicit data iteration. It iterates over each character in the data (the second line), and executes the program (the first line) for each character. The data QnN pushes the data (Q), outputs it (n), then pushes a newline (N), to be implicitly outputted. This iterates 10 times, printing a 10x10 grid of asterisks.

MathGolf, 7 bytes
♂⌂*n+♂*

Explanation
♂⌂*     Push asterisk multiplied by 10("**********")
   n    Append a newline
    +   Concatenate the two strings
     ♂* Multiply the string by 10
implicit output

Try it online!

Python 3, 23 bytes
print(10*(10*"*"+"\n"))

Try it online!
In this case, the obvious answer is best. I tried some other ways, but all were equal or longer in length.
Let me know if you have any answers to add.
23 bytes (alternative)
print(10*f"{10*'*'}\n")

24 bytes
print(10*"**********\n")

25 bytes
exec(10*"print(10*'*');")

29 bytes
print("\n".join(10*[10*"*"]))

32 bytes
for _ in range(10):print(10*"*")

43 bytes
print(*(10*"*"for _ in range(10)),sep="\n")

PHP, 26 bytes
Just used a compressed string. Has raw output of gzdeflate and contains unprintable binary data, so the code itself and direct TIO link cannot be posted here, but here is a hex dump of it:
000000  3c 3f 3d 67 7a 69 6e 66 6c 61 74 65 28 22 d3 d2  <?=gzinflate("..
000010  82 01 2e 2d 9a 33 01 22 29 3b                    ...-.3.");

Save it as a binary file then execute it like this: php asterisks.php
TIO which uses bash to run this file: Try it online!

APL (Dyalog Classic), 11 bytes
⎕←10 10⍴'*'

Try it online!
Explanation
⎕←          ⍝ Output
   10 10⍴'*' ⍝ The asterisk reshaped into a 10 by 10 grid

naz, 44 40 bytes
crossed out 44 is still regular 44 :(
1x1f6a7m9o1o4d1o0m0x1f1f1f1f1f1f1f1f1f1f

This is another one of those cases where a truly recursive definition would actually use more bytes than just repeating the f instruction.
Saved 4 bytes by using division instead of subtraction!
Try it online!
Explanation (with 0x instructions removed)
1x1f                   # Function 1
    6a7m9o1o           # Output 10 asterisks
            4d1o       # Output a newline
                0m     # Reset the register
1f1f1f1f1f1f1f1f1f1f   # Call function 1 ten times

Ruby, 15 bytes
puts [?**10]*10

Try it online!
Prints a trailing newline.
?* is the single character *
Explanation
puts [?**10]*10

      ?*        : literal '*' string
        *10     : repeated 10 times ('**********')
     [     ]    : as an element in an array
            *10 : which is also repeated 10 times
puts            : prints each element of the array appended with a newline.

W d, 7 4 bytes
°♣∩x

Uncompressed
T:s*E

Explanation
T     % Push a 10 onto the stack
 :    % Copy the top of stack
  s*  % Generate 10 asterisks
    E % Foreach in the range 1 .. 10,
      % Print 10 asterisks following a newline

Husk, 9 bytes
C10*100"*

Try it online!
Length 100 string chopped into 10 pieces.

Scratch 3.0, 4 blocks/65 bytes
SB Syntax:
when gf clicked
delete all of[o v
repeat(10
add[**********]to[o v

Picture:

Try it online Scratch!
I'm quite proud of the block count here, because it matches the byte counts of the winning answers. But SB Syntax ruined things for me. (´• ╭╮ •`)

Set, 79 bytes
set A (A+1)
set ! 42
[A/K] set ? 1
set A 65
set B (B+1)
set ! 10
[B/L] set ? 1

There's a newline at the start.

Plain TeX, 35 bytes
\def~{**********\par}~~~~~~~~~~\bye

Try this Code at Overleaf

Integral, 6 Bytes

v*)f)☼

Try it!
Explanation
v*     "*"
  )    Push 10
   f   Repeat string 10 times
    )☼ Push 10 copies onto the stack

Stack is joined with newlines & implicitly outputted

Keg, -pn, 9 bytes
`*`
*(9|⑩

Try it online!
1 shorter than the current answer.

Good, but no competition with 1+.

Yes, very competition with 1+ if you outgolf MAWP

Such rubbish, so pointless, wow

It's also funny seeing you hate it so much. ;P

... (15 chars!)

JavaScript (V8), 52 bytes
console.log((f=(c,i=10)=>i?c+f(c,--i):'\n')(f('*')))

Try it online!
JavaScript (V8), 45 bytes
console.log((f=c=>c.repeat(10))(f('*')+'\n'))

Try it online!
JavaScript (V8), 45 bytes
console.log(('*'.repeat(10)+'\n').repeat(10))

Try it online!

Pip -l, 5 bytes
'*MCt

Try it online!
Four years ago, I wrote a 7-byte Pip solution and said, "Kinda disappointed that the simple way was the shortest." Fear not, previous me: It's not the shortest anymore!
(Though technically, given our current consensus about flags, Pip and Pip -l aren't the same language... oh, whatever.)
Explanation
    t  Variable, preset to 10
  MC   Take that as the size of a grid of coordinate pairs and map a function to each pair
'*     Given a value rather than a function, MC puts that value at every location instead
       The result is a list of 10-element lists of asterisks, which we autoprint with
       every sublist on a new line thanks to the -l flag

hmm, isn't the flag added to the code length?

@Razetime That used to be the case (and Pip's flag system was designed with that rule in mind), but it's not anymore.

Rutger, 64 bytes
r=Repeat["*"];
o=Concat[r[10]];
o=Repeat[o["\n"]];
Print[o[10]];

Try it online!
Kinda self-explanatory, I hope.

Rust, 39 bytes
||for _ in 0..10{print!("{:*>11}","
")}

Try it online!
This uses * as a fill character to pad a newline. The result is printed 10 times.

Desmos, 30 bytes
29sign(mod([1,...,110],11))+13

View it online! (kinda)
Desmos doesn't have string support, so instead we output a list of 110 character codes. If you don't want a trailing newline, you can change the 110 to a 109 with no issues. Desmos also doesn't support loops properly, but if you apply operations to arrays, it applies them to each element in the array. Explanation:
           [1,...,110]           Generate array containing numbers 1 to 110
       mod(           ,11)       Find index mod 11 (0 corresponds to end of row)
  sign(                   )      Coerce to 0/1 instead of 0/1/2/...
29                         +13   Convert 0s to 13s (\n in ASCII) and 1s to 42s (* in ASCII)

GolfScript, 10 bytes
10."*"*n+*

Try it online!
10.         # Puts 10 on the stack and makes a copy of it
   "*"*     # Puts the asterisk on the stack and multiplies it by the 10 to get "**********"
       n+   # Adds a newline to the string
         *  # Multiplies by that first 10

Bubblegum, 8 bytes
00000000: d382 035e 2e7a b201

Try it online!

Bound, 13 12 bytes
10:c42:d*@RS

Thanks to Razetime for the -1 byte
Explanation:
1 # Put 1 onto the stack [1]
0 # Put 0 onto the stack [1, 0]
: # Combine the top two elements [10]
c # Copies the top element [10, 10]
4 # Put 4 onto the stack [10, 10, 4]
2 # Put 2 onto the stack [10, 10, 4, 2]
: # Combine the top two elements [10, 10, 42]
d # Convert the top element into a char [10, 10, '*']
* # Multiply the top two elements [10, '**********']
@ # Sorts the stack ['**********', 10]
R # Repeat the next command n times, where n is top element (10) ['**********']
S # Print the top char/string (creates newlines)

Try it online!

Welcome to the site and nice first answer!

12 bytes: 10:c42:d*@RS

@cairdcoinheringaahing thank you! excited to be here

@Razetime nice!

Brian & Chuck, 23 bytes
*{-?
{..........>-.+?

Try it online!
The  is the ascii code 11.
Brian:
*      "*" 11
  {-    Restart Chuck's code and subtract 1
    ?   Go to Chuck's code while the first byte is not 0

Chuck:
                    11 (This will be decremented by 1 each line)
  {                  Restart Brian's code
   ..........        Print the "*" 10 times
             >-.+    Print the newline
                 ?   Go back to Brian's code

Python 3, 67 bytes
print('\n'.join(''.join('*' for x in range(10))for y in range(10)))

Try it online!

Welcome to the site, and nice first answer!

62 bytes by saving range(10) as a variable and removing the space after '*'

Don't forget to check out existing Python solutions to this problem. The current record is 20 bytes (Python 2) / 22 bytes (Python 3).

BRASCA, 26 24 20 17 bytes
l:[{$[{'*o]xllo$]

Try it online!
Explanation
l:                   - Initialize stack
  [             ]    - Do 10 times:
   {$                -   Decrement and swap
     [    ]          -   Do 10 times:
      {'*o           -     Decrement and print *
           xllo$     -   Reset and print a newline

Lua, 31 bytes
print(("**********\n"):rep(10))

Try it online!
Not very impressive but I think simpler is shorter in this case.

can't seem to beat this :)

Python 3, 26 24 bytes
print((10*'*'+'\n')*10)

I'm new to coding and even newer to competitive programming, so don't go too hard on me :D

Oh of course, multiplication has priority over addition. Thanks dude.

C (gcc), 41 bytes
main(n){++n<puts("**********")&&main(n);}

Try it online!
Or if you don't have any problem using a function that would work only the first time it's called (because to make it work again you should reset the value of n)
C (gcc), 38 bytes
n=9;f(){puts("**********");n&&f(--n);}

Try it online!
And a 38 bytes dupe
n;f(){++n+1<puts("**********")&&f(n);}

Try it online!
Note that even the first code works only one time, it doesn't reset anything, you need to run the program again to have another 10x10 grid. However for some (questionable) reason they allow printing the grid just once per program run when using main, but not when using another function.

This prints a 10*n grid of asterisks. Taking extra input (the 10 in this case) is not allowed

@ppery fixed it, thank you so much

Nope, your answer is now a non-reusable function, so still not allowed.

Omg I am learning a lot from you! I will fix even this one

@ppery resetting the global variable at the end of the function requires too much unnecessary code and I just want you to notice that this so upvoted answer https://codegolf.stackexchange.com/a/88695/100356 doesn't reset anything either, it requires a new run for every 10x10 block. And most probably the same thing happens in most codes here and in any codegolf question. I don't see any reason why we should use double standards.

There's no double standard here. That answer is a full program, not a function. And yes, that does mean that this answer would become valid if you changed f() to main(), at the cost of 3 bytes.

Well, I think it's an arbitrary rule to pretend that a function have to be able to reproduce the result of the challenge as many time as you want, while a program is allowed to reproduce the result just one single time. Following this rule my function is not a valid answer, while the same function followed by a main is a valid answer, even though the function would not work if called again.

Full programs are self-contained and only run once before resetting, while the concept of a function is that it can be called many times from one program and be reused. It really would be easiest to just use the main function like so for 41 bytes

I get your point. But then what about a program using a non-reusable function? Is the program valid because self-contained? Or is the program a non-valid answer because functions are supposed to be called many times? Wouldn't be easier to adopt the convention that you need to make a code that is barely enough to reproduce the result, since we are already practicing this philosophy when exploiting all sorts of illegal tricks, abusing the undefined behaviour?

You aren't going to get anywhere by arguing with site consensus in the comment section of this answer. Regardless of your opinion that the rule about function reusability is pointless and arbitrary, it is a rule that this site has adopted, and therefore this answer must be edited to comply with it or deleted.

All right I am going to edit the answer. But take note that this "site consensus" you are talking about consists of 34 (six years old) upvotes to someone's opinion. By the way this opinion is based on the belief that the only purpose of functions is to cut redundancies, while I remember for example enjoying making a function to print the knight moves, even if I needed it only once, at the end of the program. And anyway even if functions were supposed to always be reusable, are programs supposed to contain undefined behaviour? This is codegolf, keep your restrictions away from here please.

If you call a non-reusable function in a full program it doesn't matter since it is impossible to call that function a second time. There need to be some boundaries, otherwise you wouldn't be able to compete fairly

So programs can have non-reusable functions, you admit their legitimate existence, but for some obscure reason they are not allowed to be used as an answer. I understand that the topic is not that important so that you could follow someone's arbitrary rule without asking too many questions, but now you got some question and you shouldn't persist in error.

Java 11, 48 chars
Method String.repeat(int)
for(int i=0;i++<10;out.println("*".repeat(10)));

Try it online!

Java 5, 53 chars
Static imports
for(int i=0;i++<100;out.print("*"+(i%10>0?"":"\n")));

Try it online!

Java 3, 60 chars
Plain old Java
for(int i=0;i++<100;System.out.print("*"+(i%10>0?"":"\n")));

Try it online!

Zsh -F, 19 bytes
yes **********|head

Try it online!
Edit: just saw this exact answer was already posted for bash :(

alt approach (22 bytes): jot -b'**********' 10

Whispers v3, 38 bytes
> "**********"
>> Output 1
>> Each 2 1

Try it online!

Templates Considered Harmful, 89 bytes
Ap<Fun<If<A<1>,Cat<St<42,42,42,42,42,42,42,42,42,42,10>,Ap<A<0>,Sub<A<1>,T>>>,LF>>,I<10>>

Try it online!
Pretty standard "10 stars 10 times" answer, in the form of a tail-recursive anonymous function.
Ap<
  Fun<
    If<A<1>,
       Cat<
         St<42,42,42,42,42,42,42,42,42,42,10>,
         Ap<A<0>,
            Sub<A<1>,I<1>>>>,
       LF>>,
  I<10>
>

ConTeXt (40 bytes)
Compile it here (note that the magic comment is only here for texlive.net and it's not needed in an offline compilation).
\let~\dorecurse\starttext~{10}{~{10}*\\}

JavaScript (V8), 31 bytes
write(`**********
`.repeat(10))

Try it online!

Java (JDK), 37 bytes
out.print("**********\n".repeat(10));

Try it online!

Python - 40 20 23 bytes
 print(("*"*10+"\n")*10) # prints a row of 10 *s then a new line, 10 times

This (freshly optimised) code prints an asterisk 10 times, then a newline (should be fixed now), then repeats that 10 times.

Well, a quick save would be with the asterisks, instead of print("**********"), try print("*"*10) and save 6 bytes. Online example here: https://tio.run/##K6gsycjPM/7/Py2/SCFeITNPoSgxLz1Vw9BA04pLoaAoM69EQ0lLSQvI//8fAA

You can also probably add a newline to the "*"*10, and then multiply that be ten as well

Fixed now - thanks for the help.

You don't define the variable n anywhere.

That's a new line. @pppery

Um, it doesn't work like that for me. I get NameError: name 'n' is not defined running this code on both Python 2 and Python 3

OH - I see the issue now, thanks for pointing it out.

Nope, still doesn't work (Try it in Python 2, Try it in Python 3) print(("*"*10+"\n")*10) would be a valid 23 byte submission.

It should work now - tested it in Python 2.7 and it worked fine.

Clojure, 35 bytes
(dotimes[_ 10](print"**********
"))

Try it online!

Elixir, 35 bytes
for _<-0..9,do: IO.puts"**********"

Try it online!

Twue, 31 bytes
a::~**********\n
::=
aaaaaaaaaa
Try it on the website!
Simply defines the replacement a which maps to printing 10 asterisks. The main body consists of 10 as. Trying a secondary replacement b::=aa or b::=aaaaa both yield 33 bytes, which is unfortunately longer.
Whereas in some Thue interpreters, outputting implicitly outputs a newline, that is not the case in Twue, which must manually insert the newline.

VBScript, 39 bytes
For i=0 to 9
WSH.Echo "**********"
next

VBScript, 53 bytes
For i=0 to 9
WSH.Echo replace(space(10)," ","*")
next

The second solution is slightly more interesting......

Duocentehexaquinquagesimal, 18 bytes
hùyy₄āÆβUW:“ã¾8½ž+

Try it online!

BRASCA, 14 bytes
l[ll['*o{]xo{]

Try it online!

yuno (abandoned), 11 bytes
」＊１０リュ」ニュア１０リュ

xxd using Jelly's codepage:
00000000: f8f6 e6e5 5bf8 5200 e6e5 5b              ẏẇȧẓ[ẏR¡ȧẓ[

Explanation
」＊　　　　　　　　　　　　    push "*"
　　１０　　　　　　　　　　    push 10
　　　　リュ　　　　　　　　    repeat "*" 10 times
　　　　　　」ニュ　　　　　    push "\n"
　　　　　　　　　ア　　　　    add / concatenate
　　　　　　　　　　１０　　    push 10
　　　　　　　　　　　　リュ    repeat "**********\n" 10 times

Equivalently written as ]*10ryu]nyua10ryu

PPL, 33 bytes
loop10{
printLine("**********")
}

There is no concept of repeating strings, and the * operator is not overloaded with strings by numbers, so I hardcoded a string of 10 asterisks and printed it 10 times using the loop keyword.

Mathematica, 24 bytes
Print@@@Table["*",10,10]

A second (simple) Mathematica proposition, same length

Malbolge, 271 bytes
Generated here (linear generator).
I tried other methods too but it took me pretty long time so I could not wait for completion.
D'`_:pon}}kXyxx5R-,s0Npn9+k#(EgDU0zyba+u)]xwvunV3210/.-,+*hg`H^c\"`_AW\UyxwvutsrqpJIHMLEDCg*@E>ba`_^]\[ZY9y765.-,+O/.nmJIHGFEDCBAya}|{ts9wvunV3210/.-,+*hg`H^c\"`_AW\UyxwvutsrqpJIHMLEDCg*@E>ba`_^]\[ZY9y765.-,+O/.nmJIHGFEDCBAya}|{ts9wvunV3210/.-,+*hg`H^c\"`_AW\Uyxwvutsrqp]

Try it online!

Arduino, 101 bytes
int i=0;void setup(){Serial.begin(300);}void loop(){if(i++<10)Serial.println("**********");else i--;}

The else case is there to prevent i from overflowing and becoming negative, since the loop() function is called indefinitely.

jq, 16 bytes
10*("*"*10+"\n")

Try it online!

Python 3, 34 bytes
for i in range(10):
 print("*"*10)

Try it online!

Welcome to Code Golf! I've edited your answer to make it a bit clearer and added a link to try it. There's a couple similar Python answers, but nice first answer!

You can save some bytes by inlining the for block, so it can be one line like for i in range(10):print("*"*10)

Also, make sure to check out our Tips for golfing in Python to see if there are any other ways to golf your code.

SNOBOL4 (CSNOBOL4), 43 bytes
Outputs two trailing LFs.
 output =dupl(dupl('*',10) char(10),10)
end

Try it online!

I noticed replacing dupl('*',10) with '**********' results in number of bytes unchanged.

Aussie++, 71 bytes
G'DAY MATE!
I RECKON x IS A WALKABOUT FROM [0TO 9]<GIMME "**********";>

Tested in commit 0a5de7e, in which for loops do not behave as per the spec. The version presented here actually works in that commit.

Why is this noncompeting?

The language used was introduced years after the question was asked, and the question does not specify that newer languages are allowed.

That rule has been obsolete since 2017, and such answers no longer need to me marked.

Oh, I didn't know that. I'll remove the marking then.
EDIT: It looks like you did for me.

KonamiCode, 103 bytes
v(^^^^>^^)>(^)v(^>)>(^^)v(>)>(^^^)v(>)S(^>)L(>)>(^^)v(>)L(^)>(>)<<>(^^)v((>))B(^)>(^)<<>(^^^)v((>))B(>)

shortC, 33 bytes
AOIa=0;a<=10;a++)R"**********\n"}

Try it online!

Hodor, 240 bytes
hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");hodor.hod("**********");

Try it online!
I'm not good at Hodor

Japt, 15 bytes
"*"p10)+"
")p10

Try it online!

Python 3, 23 bytes
Prints an extra newline at the end
print(f'{"*"*10}\n'*10)

Try it online!

Python 3, 23 bytes
print(('*'*10+'\n')*10)

Try it online!
(Note: new to codegolf and stackexchange in general, this is my first attempt at any code-golfing challenge)
Edit: this is a pretty generic answer, and pretty boring too, although valid and pretty short.

Welcome to Code Golf!

@NoHaxJustRadvylf Thank you!

Kotlin, 34 bytes
println("**********\n".repeat(10))

Try it online!

You are right, i had missread the task :)

Bits, 191 bits = 23.875 bytes
00000000000000000000000000000000000000000000000000000000000011100010110000011111011001111101100111110110011111011001111101100111110110011111011001111101100111110110011111011001110000011100011

Explained

The long string of 0s at the start is to make a string of length 10. (This is the only way to start a for loop in Bits)
11100010 starts the for loop:

1100000 is a separator so the strings don't join together
1111101100 is the code for a *. We repeat this 10 times to get **********. (Note: this is the only way to repeat a string in Bits)
11100000 prints the string

11100011 closes the for loop

Screenshot

TacO, 25 bytes
0 01
1  *"*"
*###"\n"
w
@

Explaination
The program is a 2D program which can be broken up as so:
@       ; Program Entry
w       ; Write the result of everything STDOUT concatenated together
*10     ; Repeat 10 times
  *10   ; Repeat 10 times
    "*" ; Append "*"
  "\n"  ; Append a newline

Or the psudocode:
write(repeat(10,repeat(10,"*")+"\n")

Try it online!

Uiua, 10 bytes
≡&p↯⊂.10@*

Try it online!
≡&p↯⊂.10@*    full program
         @*    the character literal '*'
    ⊂.10      the golfiest way to produce the dimensions of the matrix [10,10]
   ↯           reshape to get 10x10 matrix of '*'s
≡&p            print each row with newline

Vyxal 3 j, 5 bytes
₅•×₀÷

Try it Online!
RIP -H flag and squarify strings which could make this 3 bytes

C++, 76 bytes
I don't know if this could be golfed further, but just.
#include <iostream>
void a(){for(int i=0;i++<10;)std::cout<<"**********\n";}

No, I tried that.

You can save a few bytes by using puts from cstdio instead of cout (save in header name, function name, plus line terminator for free). Also one byte by making i global (which gets zero initialized for free).

This isn't a whole program (no main) so do you need the include?

https://tio.run/##S9ZNT07@/z/TOjcxM09Dszotv0jDOlNb28bQwFqzoLSkWENJCw6UNK1r//8HAA Here is a version with Mat's suggestions

Javascript (using external library - Enumerable) (41 bytes)
_.From("**********\n").Cycle(120).Write()

Link to lib: https://github.com/mvegh1/Enumerable/
Code explanation: This runs right in the console. Load the string into the library, which parses it to a char array enumerable. Create a new enumerable from that sequence, which is generated by cycling from start to finish 120 times (because the string length is 12, and we want 10 of them..12*10=120). I.e [1,2,3].Cycle(10) would be 1,2,3,1,2,3,1,2,3,1. Finally, join everything into a string with "" as delimiter

OH, .length lied to me ahah...I thought it would count "" and "n" as separate characters..fixed!

Next time use https://mothereff.in/byte-counter

@PatrickRoberts Got it, thanks!

C# - 88 bytes
class P{static void Main(){int i=0;while(i++<10)System.Console.Write("**********\n");}}

You can reduce this a bit by using a for look, putting int i inside it for(int i=10;i-->0;) (There is never a reason to use a straight while loop in C# code golf, a for loop is never more expensive)

I know, but then I would have been copying and pasting an already existing answer.

Ruby, 18 bytes
puts (?**10+$/)*10

Alternative version (+3 bytes)
10.times {puts ?**10}

Ungolfed (first version)
puts ('*' * 10 + '\n') * 10

Second part of 3aw5TZetdf's Perl tip works in Ruby too.

Perl, 24 bytes
print((("*"x10).$/)x10);

Swift 2, 45 Bytes
func a(){for _ in 0...9{print("**********")}}

Wolfram, 22 bytes
Grid[Table["*",10,10]]

Welcome to PPCG! I can't test right now, but I don't think this is a full program (it only displays correctly when used in Mathematica's notebook front end, which constitutes a snippet by this community's standards). If you put this in a source file and call it with wolfram -script file.m I don't think it'll print anything.  I think the shortest way to get around that would be Print@@@Table["*",10,10]. Still, nice solution! :)

You are correct. Also, your solution works and is 24 bytes long.

R
matrix(rep("*",100), nrow = 10)

Probably faster way in R, but fun utilization of matrix
Explanation
rep: repeats first argument as many times as second argument.
matrix: creates matrix from vector (first argument), and nrow is the number rows desired in matrix.

Hi, and welcome to PPCG! However, we require all code to be golfed, which this isn't. Please golf it.

To make it print the actual desired output you would need to loop cat over it, one way or another. In addition, because of vector recycling, matrix("*",nr=10,nc=10) or array("*",c(10,10)) would be more concise to get the same matrix as the one you generate.

You are right in all regards. This works :for(i in 1:10){for (j in 1:10){cat("*");if(j == 10){cat("\n")}}}

Javascript, 45 bytes
for(i=0;i<10;i++) {console.log('**********')}

even better, ES6 Javascript, 38 bytes
console.log('**********\n'.repeat(10))

open console and copy paste to test

Python 3 (23 bytes)
print(('*'*10+'\n')*10)

23 bytes - I believe '\n' is two bytes of code, but if you measured with len it will have said 22.

3var, 27 26 bytes
1 byte thanks to Business Cat

iisiia+<*>aaaF[PPPPPPPPPPO]
aaamaiis*>iiF[PPPPPPPPPPO]

I don't how do nested loops marked by F.
Try it online!

26 bytes aaamaiis*>iiF[PPPPPPPPPPO]

@BusinessCat Thanks, do you know why this and this produce different results?

I don't know. I don't see anything in the docs about needing to put loops on a new line, though they do in their examples. Maybe it's an interpreter error?

Japt, 10 bytes
'*pA +R pA

Prints * ten times, then \n, then repeat from the beginning ten times.
Demo.

Arcyóu, 21 bytes
(* "**********\n" 10)

Try it online!

Gema, 31 characters
\A=@repeat{10;**********\n}@end

Sample run:
bash-4.3$ gema '\A=@repeat{10;**********\n}@end'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Can you provide a link to anywhere?

Linkified the title, but I know about no on-line interpreter. :(

Groovy, 23 characters
print(("*"*10+"\n")*10)

Sample run:
bash-4.3$ groovy -e 'print(("*"*10+"\n")*10)'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

Lua, 30 bytes
Full program outputting via its return value.
return("**********\n"):rep(10)

I'm afraid this is not a full program, just a snippet. It produces no output by its own, relies on Lua REPL's functionality.

@manatwork it is a full program, and is also outputting by itself. All lua program are encapsulated in function inside the VM, thus they can all return a value and it is a legit way of outputing

@manatwork Oh also, you just have to read this to know it's legit.

Are you referring to the “... if and only if the challenge requires an integer as output, obviously.” part?

@manatwork this part only refer to the case you use an exit code, because an exit code is always an integer. I was refering to "If functions can output using their return values, it makes sense that programs should be able to do the same", which is what I've done: using the return value of my program

But that whole answer is only valid for integer return values, hence the "iff" at the very start. You cannot pick a single sentence from it and pretend the preconditions don't apply to it, therefore making your answer valid.

@Joey ok, let's add a new answer to this meta in this case.

Katenkyo: That still ignores the fact that programs can have only integer return values in all operating systems I know of. Things don't work that way. Case in point here, your program simply does nothing observable because returning from the main program will simply exit and physically cannot return the string you gave it as expression.

Bc, 26 characters
for(;i++<10;)"**********
"

Sample run:
bash-4.3$ bc <<< 'for(;i++<10;)"**********
"'
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

JavaScript (115 106 81 chars)

o='';
for(i=0;i<10;i++){l='';for(j=0;j<10;j++){l+='*';}o+=l+"\n";}
console.log(o);

make the program all one line, instead of using "\n", just use a literal newline by hitting enter inside two empty quotes. that should save you 4 bytes. Also, do you need a semicolon after `l+='*'?

ListSharp, 73 bytes
[FOREACH NUMB IN 1 TO 10 AS k]
{
STRG p=p+"**********"+<newline>
}
SHOW=p

Mumps, 26 Bytes.
F J=0:1:9 W "**********",!

As loops are fairly efficient (space-wise) in Mumps, I thought I'd see if the loop within a loop was shorter, but it was not; weighing in at 31 bytes:
F I=0:1:9{F J=0:1:9{W "*"} W !}

The braces are allowable loop delimiters in the InterSystems Cache version of Mumps that I use; at times they may save a byte or two golfing, but mostly they're just handy to have nested loops in a one-line routine.

Befunge '98, 31 bytes
a>:|>1++:9`#@_a,
v*'[^
>,v1
-v>

Factor, 30
10 [ "**********"print ] times

So verbose...

Pip, 7 bytes
LtP'*Xt

Straightforward: Loop 10 times. Print string of 10 asterisks each time. Kinda disappointed that the simple way was the shortest...

Fourier, 22 bytes
10(10(~X42aX^~X)aN^~N)

Try it on FourIDE!

17 :)

MSM, 19 bytes
.;;.;...;.;;.;..␍**

where ␍ is a newline.
. concatenates the two rightmost characters and ; appends a copy of the rightmost element to the end, so the first commands .;;.;... create one line **********␍ and the next commands ;.;;.;.. make 10 lines out of it.

Jade & CSS, 41 36 bytes
- for (x=0;x++<10;)
  **********

Jade is a HTML pre-processor. I'm unsure if using this is breaking any rule or if I have to include something else in the byte count. This also beats my previous entry of 60 bytes.
See it on Codepen: http://codepen.io/409/pen/ZOPgdJ
Thanks to Business Cat for saving 5 bytes.

You can save 1 byte by doing x++<11; instead of x<11;x++. I think you can also omit the var. Also this makes a 10x11 grid, you need to change the 11 to 10.

Hey, thanks for the improvements @BusinessCat

Groovy, 23 characters
10.times{println'*'*10}

Please use code block markup (indent each line with 4 spaces or enclose it between
 and
 tags) for your code, so scripts like Code Golf UserScript Enhancement Pack can insert the length beside the code.

@manatwork Done. I'm new here; had no idea that was a thing.

Bash + coreutils + X11 term - 7 keystrokes
Exact keys to hit:

<Alt>+1
0
0
* (<Shift>+8)
<Return>

Requirements:

Your terminal window must be exactly 10 characters wide.
Your terminal prompt (PS1) should be empty.
Your working dir must be empty.

We count submissions like this in keystrokes, not bytes. So this would be 2 more keystrokes because of alt and shift.

Stata, 49 bytes
loc i=1
wh `i'<11 {
di "**********"
loc i=`i'+1
}

Output
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

ISOLADOS, 131 bytes
ISOLAADOOOOOOOOOOOS ISOLAAAAAAADOS ISOLAADOOOOOOOOOOS ISOLAAADOOOS ISOLAAAAAAAADOS ISOLAADOOOOOOOOOOS ISOLAAADOOOS ISOLAAAAAAAAADOS

ISOLAADOOOOOOOOOOOS    push 11
ISOLAAAAAAADOS         chr(a + 31)
ISOLAADOOOOOOOOOOS     push 10
ISOLAAADOOOS           push a * b
ISOLAAAAAAAADOS        push [a]
ISOLAADOOOOOOOOOOS     push 10
ISOLAAADOOOS           push a * b
ISOLAAAAAAAAADOS       join list by new lines

Racket 36 bytes
(for((j 10))(displayln"**********"))

Groovy 46 Bytes
(1..10).collect{''.center(10,'*')}.join('\n')

https://groovyconsole.appspot.com/script/5102912250314752

SX, 21 bytes
和(0,10):我('*'*10)

Actually: this compiles (technically, it just becomes Python) directly to Python. It is the same as:
for i in range(0,10):print('*'*10)

The SX code is 21 bytes long, and please split your answer in multiple answers for multiple submissions

Generally is better to post solutions in different languages in different answers, so they can be upvoted / downvoted separately. For example your Ruby solution is essentially identical with John Ramos's Ruby answer, so that may attract some downvotes.

11 bytes off: print(("*"*10+"\n")*10)

@TùxCräftîñg, that would be duplicate of helloworld922's Python 3 answer (or if you make it Python 2, then duplicate of shooqie's answer).

I'm so sorry. I didn't even read any of the answers. I just answered. I'll delete my answers for Python and Ruby.

Prolog (SWIPl), 64 / 69 bytes (depending on how to count)
-1*_.
A*0:-writeln(*),C is A-1,C*9.
A*B:-write(*),C is B-1, A*C.

Query with
9*9.

Online Example
Try it online, but take note that since writeln/1 has a bug in Swish, causing it to print a new line before as well as after. I've replaced it with write/1,nl/0 which should be (according to documentation) its equivalent. This raised the byte count of the example.
On the Byte Count
I'm not sure how to count the query, but if it is to be counted towards the total byte count, it's 5 bytes (including an Enter).

D2, 11 bytes
!7;//.|a:|a

Explanation:
!7 is expanded to 7 +, so it set the current cell to 7.
; switch to the second shift state (7 is *)
/code|digit repeat code digit times (digit is base 36).
. print the character in the current shift state (so here, * is printed).
: print a newline in shift mode 2.

Crystal, 21 bytes
puts ("*"*10+"\n")*10

How does it work?

"*" * 10            = "**********"
"**********" + "\n" = "**********\n"
"**********\n" * 10 = "**********\n**********\n[...]"

Stuck, 10 Bytes
Very simple implementation here, no tricks ;)
'*10*N+10*

Explanation:
'*           # Enter char mode, puts '*' on the stack
  10*        # Multiply string by 10, puts '**********' on the stack
     N+      # Push a newline to the stack and append to the asterisks
       10*   # Multiply that string by 10 and implicitly print.

memes, 17 bytes
d5+5’{p

Needs ********** as input, therefore +10.
d      Don't print result
5+5    10 times
’      loop
{p     Print input

C++ 83 bytes 82 Thanks to matthew roh!
#include <iostream>
int main(){for(int i;i++<10;){std::cout<<"**********"<<"\n";}}

Try Me Online!

Maybe i++<10 would help?

Unfortunately It seems to returns an invalid syntax error :\

Hm? It works for me.

Amateur Mistake... As the last argument in a for statement I didn't expect ; was required etc. for(int i;i<10;i++) returns an error expected ')' before ';' when written as for(int i;i<10;i++;)

8th, 28 bytes
( "*" 10 s:* . cr ) 10 times

Scala, 23 bytes
print(("*"*10+"\n")*10)

Almost the same as python solution.

Perl, 22 bytes
print"**********\n"x10

QC 41 bytes
&FF002A2A2A2A2A2A2A2A2A2A0D0AFF##########
&FF00 Write hex to memory at address 00 until FF is reached
2A2A2A2A2A2A2A2A2A2A0D0AFF 10 asterisks with a new line and the terminator at the end
########## Print contents of memory 10 times until first 00 is reached

Could be made shorter if loops were used.

Z80 TI-83+, 53 bytes
.nolist
#include "ti83plus.inc"
#define    ProgStart    $9D95

.list
.org    ProgStart - 2
    .db    t2ByteTok, tAsmCmp
    bcall(_homeup)
    ld A, 0
    ld (PenCol), A
Do:
    inc A
    ld hl, msg
    bcall(_PutS)
    bcall(_NewLine)
    cp 10
    jr NZ, Do
    ret
msg:
    .db "**********", 0
.end
.end

Compiled with SPASM.

Syms, 24 bytes
{*}10;*[[[[[[[[[{~>[)}[)

The interpreter as provided errors immediately, but changing line 2 to if True: fixes it. (Is this allowed? Seems like it.)
Explanation:
{*}10;*[[[[[[[[[{~>[)}[)
{*}                       Add '*' to the stack.
   10;*                   Repeat it 10 times.
       [[[[[[[[[          Duplicate 9 times (there are now 10 copies on the stack)
                {~>[)}    Swap, output, duplicate, run (prints element below tos (top of stack) and then executes tos, stack is now (copies, this))
                      [)  Duplicate and run (causes infinite loop, exits when '*'*10 copies run out)

Cardinal, 41 bytes
%++=tt*=>"*******" v
        ^~?-~,"***"<

Try it online!

25 bytes

Python 3 (35 bytes)
for x in range(1,11):print("*"*10)

range(10) works.

Japt, 9 bytes
Ao@'*pAÃ·

Try it online!
Non-competitive solutions using the new flag features in Japt:
-R flag.
-x flag.
-Sx flags.
-P flag.

OIL, 55 44 41 bytes, noncompeting
Annotated here for better understanding; remove everything after each # in each line to make it work.
**********# asterisk storage
10#if what's in
14#line 14 (marked with $)
1#is identical to 10 (line 1)
13#jump to line 13 (marked with &)
6#else to line 6; the next line
4#print what's in line 0; 10 asterisks

11#print a newline
8#increment line 14 (marked with $)
14
6#jump to the beginning (line '' == line 0)

3#exit &
0#counter $

RProgN 2, 8 bytes, Noncompeting
Noncompeting because Language Postdates challenge
°{°`**}*

I decided to take another stab at this, with a much better version of RProgN.
Explained
°{°`**}*
°      *    # Run the contained function Ten (Which ° is a constant for) times.
 {°  *}     # Repeat the referenced string 10 times.
   `*       # Asterisk Literal.
            # This results in 10 strings of 10 `*`s on the stack, which prints as expected.

Try it online!

OCTAVE, 36 bytes
strrep(num2str(ones(10,10)),"1","*")

Makes a 10 by 10 matrix of ones, converts these to strings and then changes the ones to *'s.

Syms 1.4, 12 bytes (noncompeting)
$
$*10*+10*>

Try it online!

C#, 96 bytes
static class P{static void Main(){for(int i=1;i<11;i++)System.Console.WriteLine("**********");}}

Try it online

Welcome to PPCG! Firstly, you should specify the language and byte count; secondly, this isn't a full program or function, so doesn't meet the standard requirements; thirdly, you can save a bunch of bytes by removing unnecessary whitespace and changing the comparison symbol, like so: for(int i=1;i<11;i++)Console.WriteLine("**********\n");

If this is C#, read this post to learn what your answer should be like. Also, have a look at the other answers to see what the standard format is (header with language name and bytecount, then code...).

Micro, 15 bytes
"*"10*10c+10*:/

incidentally, the ascii code for newline is 10, so: 10c

k, 12 bytes
`0:10 10#"*"

Try it online.
Explanation:
   10 10#"*" /make 10 by 10 matrix of asterisk characters
`0:          /output each row as a line

4, 56 bytes
4, 5, 6!
3.600426011060310604018016021080250010202049503101010494

Try it online!
For explanation see verbose mode in the tio link - quite straightforward initialization of cells and nested 10x10 loop.

SOGL V0.12, 6 bytes
LL **∙

Try it Here!

Google Sheets, 22 Bytes
Anonymous worksheet function that takes no input and outputs a 10 x 10 grid of *s  to the calling worksheet cell.
=REPT("**********
",10

Acc!!, 68 bytes
Count i while i-10 {
	Count v while v-10 {
		Write 42
	}
	Write 10
}

Try it online!

SNOBOL4 (CSNOBOL4), 56 50 bytes
O	OUTPUT =DUPL('*',10)
	X =LT(X,9) X + 1 :S(O)
END

Try it online!

ABCR, 36 bytes
)))))))BAAAAA4*xAb)))B(7OOOOOOOOOOP(x

Pushes 42 (the character code for *) to queue A, 10 (\n) to B, and then for each value from 9 to 0 print out ten copies of A as a character and one copy of B.

dc, 41 bytes
[1-d0!>C]sR[42Pd10%0=NlRx]sC[10P]sN100lRx

Try it online!
I know there's dc answer, just wanna do it without dumping stack)

Python 3, 43 34 31 28 bytes
for i in[1]*10:print(10*'*')

Saved 9 bytes thanks to Simon
Saved 3 bytes thanks to Wheat Wizard
Just sprints ten asterisks and in a loop.

There is no need to print \n since each print starts with a new line. Also you can shorten 10*'*'. If you swap to Python 2, you can save another byte by removing a bracket. 31 bytes

30 bytes

You can use something other than a range for example [1]*10

If you do [1]*10 you don't need the space after in.

FALSE, 34 33 26 23 bytes
11[1-$]["**********
"]#

Micrsocript II, 13 bytes
{"*"s10*P}s9*

Momema, 44 bytes
a000b0-9 42 0+1*0b=+-10*0-9 10 1+1*1a=+-10*1

Try it online!
Explanation
                                                                     #  b = 0
a   0        #  label a0: jump past label a0 (no-op)                 #  do {
0   0        #            [0] = 0                                    #    a = 0
b   0        #  label b0: jump past label b0 (no-op)                 #    do {
-9  42       #            output chr 42                              #      print '*'
0   +1*0     #            [0] = 1 + [0]                              #      a += 1
b   =+-10*0  #  label b1: jump past label b((1 + !!([0] - 10)) % 2)  #    } while (a - 10 != 0)
-9  10       #            output chr 10                              #    print '\n'
1   +1*1     #            [1] = 1 + [1]                              #    b += 1
a   =+-10*1  #  label a1: jump past label a((1 + !!([1] - 10)) % 2)  #  } while (b - 10 != 0)

Whitespace, 91 bytes
[S S S T    T   S S T   S S N
_Push_100][N
S S N
_Create_Label_LOOP][S S S T N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   T   S N
_If_negative_Jump_to_Label_EXIT][S S S T    S T S T S N
_Push_42_*][T   N
S S _Print_as_character][S N
S _Duplicate][S S S T   S T S N
_Push_10][T S T T   _Modulo][N
T   S T N
_If_0_Jump_to_Label_NEWLINE][N
S N
N
_Jump_to_Label_LOOP][N
S S T   N
_Create_Label_NEWLINE][S S S T  S T S N
_Push_10][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Explanation in pseudo-code:
Integer i = 100
Start LOOP:
  i = i - 1
  If(i < 0)
    Exit program
  Print "*"
  If(i modulo-10 == 0)
    Print new-line
  Go to next iteration of LOOP

Charm, 50 bytes
f := 10 repeat i
[ [ " * " pstring ] f newline ] f

Try it online!
Funnily enough, this doesn't use loops at all, just repeated code.

C, gcc 36 bytes
recursive solution. One downside is you need to pass 2 when you call the function to get 10 rows.
f(a){a<puts("**********")?f(a+1):0;}
This alternative addresses that issue and you don't have to call the function from main since main is now the recursive function:
main(a){a<puts("**********")-1?main(a+1):0;}
gcc also resolves #include "stdio.h" missing and variable a is implicitly set to an int and initialized to 0.

You're not supposed to take input, I believe.

The second one addresses that. The second one is the entire .c file and takes no arguments when you run the executable.

I see. You need to make that clear then(put the correct code in a code block under the header).

The solution you have at the top is an entirely invalid solution, so chuck it and just leave the valid one.

Try it online!

PHP, 60 45 Bytes
Try it online (original answer)
Try it online (saved 15 Bytes thanks to @Titus)
Code (Original)
<?=strtr(str_repeat(base_convert("1ku",36,2),10),["
","*"]);

Code (Titus suggestions)
<?=strtr(str_repeat(11111111110,10),10,"*\n");

About the edit
The change is, using str_repeat(base_convert("1ku",36,10),10) actually uses more bytes than str_repeat(11111111110,10) and the use of string for replacements on strtr instead of an array.
Explanation, Why "1ku"?`
The solution is repeat the string "**********", lets take the base 2 number 11111111110
base 10 = 2046
base  2 = 11111111110
base 36 = 1ku

Basically is repeat a compressed string, and with strtr replace each 1 with a "*" and 0 with a \n

Why don´t You just take a string with the bits instead of the packed number, and use strings instead of array for translation? 45 bytes: <?=strtr(str_repeat(11111111110,10),10,"*\n"); (decbin(2046) is one byte longer than that.) Nice idea though.

(and while you´re at it, you can fix **strtr** to strtr ;-)

I just realize that yeah, it's less bytes by using 11111111110 instead of base_convert("1ku", 36,10), i was trully focused on compress the string rather than check the byte count, gonna edit the answer, ty @Titus

Prolog (SWI), 62 59 55 54 bytes
t.
b:-between(0,9,_).
?-b,(b,write(*),1=0;t),nl,1=0;t.

Try it online!

Pari/GP, 31 bytes
for(i=1,10,print("**********"))

Try it online!

Python 3, 28 bytes
print(*['*'*10]*10,sep='\n')

Try it online!

Python 2, 21 bytes
exec'print"*"*10;'*10

Try it online!

Glee, 17 bytes
('*'%%10\)%%10,,\

Explanation:
('*'                          create '*'
    %%10                      reshape to length 10
        \)                    monadic segment with CRLF
          %%10                reshape to sequence length 10
              ,,\             expose with LF separators

Ahead, 21 18 bytes
~oK:k9*'N@k=11:+1~

Try it online!

Powershell, 12 bytes
@('*'*10)*10

Explanation
  '*'*10      create a string with 10 '*'
@('*'*10)     create an array with one element of string with 10 '*'
@('*'*10)*10  repeat elements of this array 10 times

There is solution from AdmBorkBork.

A0A0, 145 bytes
A0A0
A0C3G1G1G1G1G1G1G1G1G1G1G1A0
A0P42P42P42P42P42P42P42P42P42P42G3P10A0
A0A1G-3G-3G-3G-3G-3G-3G-3G-3G-3G-3G-3A0
G-3
G-2G-2G-2G-2G-2G-2G-2G-2G-2

The top five lines are for the loop construction. A0A0 deletes instructions whenever it runs them, so those lines ensure that the loop keeps running. On line 3 are ten P42 instructions which print * (42 is the ascii code for an asterisk). The P10 instruction prints a new line.
The bottom line acts as a counter. For every execution of the loop it jumps to there and then jumps back to the loop. This consumes an instruction on that line. There are exactly nine instructions, so when it tries to go there when it has already printed ten lines the program will halt execution (since an empty line swill stop execution in A0A0).

Pascal (FPC), 57 bytes
var i:word;begin for i:=0to 9do writeln('**********')end.

Try it online!
This is probably the best one as I don't see how this can be improved in 9 characters or less which could be gained by removing *s.

ESOPUNK, 167 78 77 bytes
MARK L
@REP 10
COPY 42 #STDO
@END
COPY 10 #STDO
TEST X = 9
ADDI X 1 X
FJMP L

I haven't been bothered to implement the preprocessor, but this should work when I do.

would it be possible to do an inner repetition? i.e. @REP 10 / @REP 10 / COPY 42 #STDO / @END / COPY 10 #STDO / @END

(also, does this language exist online anywhere?)

@ETHproductions  Nesting @rep is explicitly not allowed in the game's docs. Link added in header.

Julia 1.0, 23 bytes
print(("*"^10*"\n")^10)

Try it online!

You can change the \n for a literal newline

Assembly (NASM, 32-bit, Linux), 122 bytes
mov ecx,10
n:push 0xa202a2a
push '****'
push '****'
loop n
mov edx,120
mov ecx,esp
mov ebx,1
mov eax,4
int 128
add esp,120

Try it Online!

If you're scoring by assembler code and not machine code, use some NASM magic

@EasyasPi I try to make it portable

x86_16 machine code - 37 bytes
B4 0E            MOV AH, 0EH
B9 000A          MOV CX, 10
8B D1            MOV DX, CX
8B D9            MOV BX, CX

             .LOOP:
B0 2A            MOV AL, "*"
CD 10            INT 10H
E3 02            JCXZ .NEWLINE
E2 F8            LOOP .LOOP

             .NEWLINE:
B0 0A            MOV AL, 10
CD 10            INT 10H
B0 0D            MOV AL, 13
CD 10            INT 10H

8B CB            MOV CX, BX
4A               DEC DX
74 02            JZ .EXIT
75 E9            JNZ .LOOP

             .EXIT:
B8 004C          MOV AX, 4C00H
CD 21            INT 21H

Running using DOSBox :

Java, 46 bytes
$->System.out.print("**********\n".repeat(10))

Try it online!

Swift, 54 bytes
for _ in 0...9 {print(String(repeating:"*",count:10))}

Try it online!

X86-64/Linux Machine Code, 32 bytes
Try it online!
Usage:
$> gcc -s -static -nostartfiles -nodefaultlibs -nostdlib -Wl,--build-id=none print.S -o print
$> ./print

Notes:

Size is measured in machine code (i.e 32 bytes of PROGBITS; .text, .data, etc...)
-4 more bytes without EXIT_CLEANLY (it will segfault to exit).

/* Comment out EXIT_CLEANLY to save 4 bytes. */
#define EXIT_CLEANLY

    .global _start
    .text
_start:
    /* Incoming registers are zero.  */

    /* Use stack for storage.  */
    push    %rsp
    pop %rsi

loop:
    /* '*' in output buffer.  */
    movb    $0x2a, (%rsi)

    /* First round we have SYS_read + length 0 which is essentially
       a nop.  */
    syscall
    /* Assuming no IO error, read(0) will return 0.  */

    /* bh is initially 0, so this won't loop in initial fallthrough.  */
    decb    %bh
    jg  loop

    movb    $0xa, %bh   /* 0xa == '\n'. */
    movb    %bh, (%rsi)
    /* Initial round this will be a nop, same as above.  */
    syscall
    /* SYS_write.  */
    movb    $1, %al
    /* STDOUT.  */
    movl    %eax, %edi
    /* 1-byte at a time.  */
    movb    $1, %dl

    /* After 10 iter this will have signed overflow.  */
    addb    $0xc, %bl
    jns loop
#ifdef EXIT_CLEANLY
    /* Exit.  */
    movb    $60, %al
    syscall
#endif
```

morsecco: 109  bytes
The shortest way seems to be to define a new command repeating a given string a given times:
.  . .- .- --.. .. - -. - . -. -.-. . ..  . -. .-- . -.-.-. -.- - . -.-. -. . -.-. -.- - -.-. . . -.-. -. ---

The command itself is only 37 bytes:

. .- .- to decrement the number (Enter minus 1 and Add)
--.. .. to Zeroskip to the .., leaving the input string
- -. - . we need some stack juggling to duplicate the next of stack (over and swap)
-. is the recursive call with the decremented number
-.-. . Concatenates the returned string from the command to itself
.. is currently not used, so it can currently be used as a skip target. This may fail in future versions of morsecco

Unfortunately, the surrounding code is twice as long:

. -. .-- Writes the code to address -.
. -.-.-. -.- - Enter 42 and Konvert to Text
. -.-. -. Enter 10 and call the new command
. -.-. -.- - -.-. . add the newline to the string; expensive, but necessary
. -.-. -. --- call the new command again with 10 and Output

Fun fact: this is the length of the challenge output (100 stars plus 9 newlines). Always keep in mind that morsecco wastes a factor 5 of bytes by restricting itself to only three symbols. With 22 real information bytes, it could compete.

YASEPL, 26 bytes
=l$10»=f$42»;f,10ſl;f,10<

Easyfuck, 24 21 bytes

ke#ä/DCSűWîUµŻSHYSHY|ąĺÔ+ž]

due to lack of unicode representations for c1 control characters, they have been replaced by their superscripted abbreviations
Decompressed:
5Y$>!>!{+{J[->[->.<]!.<]

5Y$>!>!{+{J[->[->.<]!.<]
5Y                       set cell 1 to 80 (5*16) and flip the bit order setting it to 10
  $>!>!                  copy cell 1 to storage and set cells 2 and 3 to storage
       {+{               left-shift, increment, and left-shift again cell 3, setting it to 42
          J[           ] go to cell 1 and begin a while loop
            ->[    ]     decrement cell 1 and go to cell 2 to begin another while loop
               ->.<      decrement cell 2 and print cell 3 (42 is *)
                    !.<  set cell 2 to storage and print it (10 is new line)

HTML, 136 bytes
**********
**********
**********
**********
**********
**********
**********
**********
**********
**********

You can use

I can use  too

This answer is valid and allowed, but it's also extremely boring and unimaginative.

Ok, Can I post it in Markdown?

You can easily get this to 114 bytes with
 followed by the 109-byte text...

I was hoping to join in on this one but unfortunately do not have the reputation for here yet. I'm not sure if this is an applicable method, but using html/emmet you can get this down to 20 bytes. ({**********}+br)*10
Alternatively p{**********}*10 is 16 bytes. New user to this site, so I'm unsure if the tab character counts.