ArnoldC, 171 bytes

IT'S SHOWTIME HEY CHRISTMAS TREE i YOU SET US UP 10 STICK AROUND i TALK TO THE HAND "**********" GET TO THE CHOPPER i GET DOWN 1 ENOUGH TALK CHILL YOU HAVE BEEN TERMINATED 

Just for the fun of it. Nothing fancy going on here, just loops 10 times printing ********** each time.

Racket, 43 36 bytes

It's nice to see friendly Racket competition on here :).

(for([i 10])(displayln"**********")) 

Chef, 252 bytes

Was purely for fun trying to learn Chef.

Try it online!

a. Ingredients. 42 b 10 c 10 d 13 e Method. Put e into mixing bowl. F the c. Put b into mixing bowl. F the c until fed. Liquefy contents of the mixing bowl. G the d. Pour contents of the mixing bowl into the baking dish. G the d until ged. Serves 1. 

TSQL, 45 bytes

SELECT TOP 10 REPLICATE('*',10) FROM systypes 

Above query use TSQL REPLICATE function to replicate * 10 times and systypes is a system view in SQL Server which list out system specified and user defined data types.

Try it here

This is my answer on Code Golf and I hope I am doing it correctly.

Backhand, 28 bytes

aH~0}|{:& [a ^v&v"*******" ^ 

Try it online!

It may seem weird that the quotes only contain 7 asterisks, but there's a reason for it.

Explanation:

Note that the pointer usually moves in steps of 3

a Push 10 as the counter 0 |{ Push 0 to not get reflected and enter the loop & Store the counter in the register a Push a newline v v Decrease the step value to 1 "*******" Push 7 asterisks ^ Increase the step value to 2 and reflect " * * * " Push 3 asterisks & Restore the counter ^ Increase the step counter to 3 [ Decrement the counter : Duplicate the counter }| Repeat the loop if the counter is not zero ~ Otherwise, pop the excess copy of the counter H And terminate, printing the contents of the stack 

Rust, 49 bytes

fn main(){print!("{}","**********\n".repeat(10))} 

My first code golf answer!

Charcoal, 4 bytes

Ｇ+α* 

Try it online!

The code translates as: draw a filled polygon (Ｇ); give it four equal sides going in the four cardinal directions (+); each side should be 10 characters (α, a variable preinitialized to 10); use asterisks (*).

swift 5, 35 bytes

(0...9).map{$0;print("**********")} 

The $0 is only needed to prevent a compiler error.

[Update]

Try it online:

https://tio.run/##Ky7PTCsx@f9fw0BPT89SUy83saBaxcC6oCgzr0RDSQsOlDRr//8HAA

Factor, 30 bytes

10 [ "**********"print ] times 

Try it online!

Okay, is there a factor vocabulary to print string \$n\$ times? I couldn't find a documentation?

GForth 36 Bytes

: A 10 0 do ." **********" CR loop ; 

Commodore BASIC (C64/128, PET, VIC-20, C16/+4, THEC64/Mini, Ultimate64) ~35 tokenised BASIC bytes

0a$="**********":fori=.to9:?a$:next 

Very simply, a string is created called a$; this is of 10 asterisks. This is printed to the screen in a for/next loop, which is from zero to nine inclusive. Each string is printed onto a new row on the screen.

A few tokenised BASIC bytes could be saved with:

0fori=.to9:?"**********":next 

Though I think this would be less performant (not that performance will matter with such a trivial BASIC listing).

Python 3, 25 24 23 bytes

Newest answer

print(('*'*10+'\n')*10) 

I'm an idjot, I don't need so many parentheses.

2^nd answer

print('**********\n'*10) 

I shaved off a byte doing it more simply.

1^st answer

print((('*'*10)+'\n')*10) 

Python can multiply strings, but most of your saving are eaten by print(), so it goes like this:

print((('*'*10)+'\n')*10) print( # Print to console (('*'*10) # Put 10 '*' in a row +'\n' # Append a new line character at the end of the 10 '*' )*10) # Now do it 10 more times 

Python 3, 25 bytes

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

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.

Headascii, 44 43 bytes

+++++^^DONE.U^[]]]]++[{]PPPPPPPPPPRPD-^)!:} 

Try it here! Code will need to be copied, and executed like this:

erun("+++++^^DONE.U^[]]]]++[{]PPPPPPPPPPRPD-^)!:}") 

My first code golf answer. One trailing newline.

Thanks to @Aaroneous Miller for -1 by showing me N is valid for no input programs.

Explanation:

+++++^^DONE.U^[]]]]++[{]PPPPPPPPPPRPD-^)!:} +++++ # add 5 to r0 ^^ # add r0 to r1 twice D # set r0 to r1 (10) O # push r0 to array N # set r0 to 1 if no input E. # jump to r0th . and set non string registers to 0 U # set r0 to first item in array (10) ^ # add r0 to r1 [ # set r2 to r0 and set r0 to 0 ]]]] # add r2 to r0 4 times (40) ++ # add 2 to r0 [ # set r2 to r0 (42) and set r0 to 0 { } # loop ] # add r2 to r0 (42) PPPPPPPPPP # concatenate r0 (*) to the string register 10 times (**********) RP # set r0 to the first item of the array again (10) and concatenate r0 (\n) to the string register (**********\n) D-^ # decrement r1 and set r0 to r1 ) # if r0 != r3 (0), jump past next :. either way, set r0 to r3 (0) ! # print string register : # jump to next ; (eof halt) 

If there's a better way to format these, let me know, I just saw everyone else doing it haha

Nibbles, 4.5 bytes (9 nibbles)

`/10^$"*" 

Attempt This Online!

 ^ # replicate "*" # an asterisk $ # 100x # (this is a default value for $ # when the program receives no input) `/ # split into chunks of 10 # 10 

Cheddar, 24 bytes

print(['*'*10]*10).vfuse 

'*'*10 builds the string **********.

Then, ['**********']*10 creates 10 copies of that string.

Then, vfuse joins by newline.

SpecBAS - 18 bytes

?(("*"*10)+#13)*10 

? is shorthand for PRINT, #13 is the equivalent of \n in other languages.

Perl, 17 bytes

Requires -E at no extra cost.

say"*"x10for 0..9 

Usage

perl -E 'say"*"x10for 0..9' ********** ********** ********** ********** ********** ********** ********** ********** ********** ********** 

Saved a byte thanks to @manatwork!

><>, 35 bytes

ab*1-:?!v:20. >'*'o72.~ ^?%b;!?l<oa 

Try it online!

dc, 22 18 bytes

[**********]ddddff 

Invoked in bash as

echo [**********]ddddff | dc 

Explanation:

[**********] # This is dc's way of making a string, which is then pushed onto the stack dddd # d is for duplicate, so we duplicate it 4 times on the stack ff # print the whole stack twice, which contains 5 repetitions of 10 *'s (x2) 

Thanks to LeakyNun for saving 5 4 bytes; Edited from 5 since I can't count.

C#, 53,122 108 bytes

Seeing that I'm seriously new to code golf... I'll give it a shot in c#

public class Program{public static void Main(){for (var i=0;i<10;i++)System.Console.Write("**********\n");}} 

try it online

Python 3, 25 23 bytes

Hey I actually outgolfed someone :).

print(("*"*9+"*\n")*10) 

if stderr is valid, 22 bytes

exit(("*"*9+"*\n")*10) 

realised that execing didn't actually golf it down :(

25 bytes answer

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

Works by concatenating ten copies of print('*'*10); and execing, which in turn works by concatenating '*' 10 times and printing

MSX BASIC, 40 30 bytes

1FORR=1TO10:FORC=1TO10:?"*";:NEXT:?:NEXT 

Update: D'oh... much shorter if I just print whole rows:

1FORR=1TO10:?"**********":NEXT 

Same, 239 bytes

ЕEЕEЕEЕEЕEEЕЕEЕEЕEЕЕEΕЕEЕEEЕЕЕΕЕЕEЕEЕEЕEЕEЕEЕEЕEЕEЕEΕEEΕEЕΕЕEEЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕЕΕЕЕEЕEЕEЕEЕEЕEЕEЕEЕEЕEЕЕЕЕEΕEEΕЕЕΕΕΕ 

Samebly code used to generate this:

add 5 mstore add 3 mult add 2 mstore clear add 10 while minc mstore mdec mread outc outc outc outc outc outc outc outc outc outc clear add 10 outc minc mread mdec dec end 

><>, 22 15 bytes

'*o'l),lb%a$?$o 

The program exits with an error and the output has no trailing newlines. Try it online!

'*o' Push 42 '*' and 111 l), Divide the 42 by (111 > length of stack) - this is a no-op initially and a division by zero error later on lb% Push (length of stack) % 11 a$ Put 10 '\n' beneath that ?$ If (length of stack) % 11 is nonzero, swap top two chars, moving the '*' above the '\n' o Output top char, leaving the other char and hence increasing the length of the stack by 1 

><> is a toroidal 2D language, so the above runs in a loop until the division by zero causes the program to error out.

Alternative 15s (which work for different reasons):

'*o'l),lb%?!{oa '*o'l),lb%?!}oa 

Awk, 37 35 characters

BEGIN{for(OFS="*";++i<NF=11;)print} 

Thanks to:

• Cabbie407 for combining the OFS and loop-based solutions (-2 characters)

Sample run:

bash-4.3$ awk 'BEGIN{for(OFS="*";++i<NF=11;)print}' ********** ********** ********** ********** ********** ********** ********** ********** ********** ********** 

QBIC, 18 bytes

[1,z:?@**********| 

Explanation

`[` starts a for-loop `@**********|` introduces the string literal "**********" and `?` prints it `z` is short for 10 FOR-loops are auto-closed at the end of the program code. 

If you'd like me to demonstrate more features of QBIC, upvote this: Showcase of Languages

QBIC's a work-in-progress. The current state would allow us to solve this in 15 bytes:

 [|?@**********` 

[ starts a FOR-loop, but the number of arguments is flexible. When | directly follows [, the FOR loop runs from 1 to 10. One argument makes it go from 1 to N, two args runs from M to N and three args introduces an increment:

[3,11,2| --> FOR a=3 TO 11 STEP 2 (or JS-style: for(a=3;a<11;a=a+2){} ) 

Brain-Flak, 77 bytes

(((()()()()()){})<>){({}<((((((((((<>(((({})<>)){}){}()()))))))))))>[()])}{} 

Try it online!

The naive approach is 91 bytes:

((()()()()()){}){({}<((((((((((((((()()()){}()){})){}{}))))))))))((()()()()()){})>[()])}{} 

But this approach holds an extra ten on the alternate stack to create large numbers easier. Unfortunately, since looping is so expensive in brain-flak, it's actually shorter to just push * 10 times directly rather then setting up a loop to do it.

I'm sure this could be made shorter.

Javascript: 65 bytes

s="";for(i=1;i<=100;i++){s+="*";if(i%10==0)s+="\n"}console.log(s) 

-- After it has been pointed out to me in the comments on the question, that we don't have to care about the dev-tools combining repeated output (as it can be turned off) I rewrote it as following

Javascript: 42 40 bytes

i=10;while(i--)console.log("**********") 

(Saved 2 bytes thanks to @kamoroso94)