C, 36 bytes

main(i){while(printf("%d ",i++)<3);}

This works because the loop terminates after the first 2 digit number.

Bash, 12 characters

echo {1..10}

Sample run:

bash-4.3$ echo {1..10}
1 2 3 4 5 6 7 8 9 10

Bash + coreutils, 10 characters

(Just trying to be funny and using ': No such file or directory↵ls: cannot access ' as separator.)

ls {1..10}

Sample run:

bash-4.3$ ls {1..10}
ls: cannot access '1': No such file or directory
ls: cannot access '2': No such file or directory
ls: cannot access '3': No such file or directory
ls: cannot access '4': No such file or directory
ls: cannot access '5': No such file or directory
ls: cannot access '6': No such file or directory
ls: cannot access '7': No such file or directory
ls: cannot access '8': No such file or directory
ls: cannot access '9': No such file or directory
ls: cannot access '10': No such file or directory

Bash + coreutils, 6 characters

(Just trying to be boring. Or not just trying…)

seq 10

Sample run:

bash-4.3$ seq 10
1
2
3
4
5
6
7
8
9
10

Jelly, 2 bytes

⁵R

Explanation

⁵  Return the fifth command line argument or 10
 R Range
   Implicit output

05AB1E, 2 bytes

Code:

TL

Explanation:

T   # Constant for 10
 L  # Range

Try it online!.

Brainfuck, 58 bytes

-[----->+>+<<]>--<+++++[<++<++>>-]<<-[->>>.+<<.<]>>>>--.-.

Try it online!

Pyth, 2 bytes

ST

First time I've used a golfing lang to answer!

Explanation:

S    1-indexed range. [1, 2, ... A].
 T   Variable. Initialized to 10. (Ten)
     Implicitly printed.

CJam, 6 5 bytes

A,:)`

1 byte saved thanks to Luis Mendo

Output: [1 2 3 4 5 6 7 8 9 10]

Explaination:

A,      e# Push a list from 0 to 9.
  :)    e# Increment all values.
    `   e# Stringify the list.

Try it online!

MATL, 3 bytes

10:

Try it online!

Actually, 9 Bytes

19`;1+`na

Try it here!

Explanation:

19`;1+`na

1           Push 1 to stack
 9          Push 9 to stack
  `;1+`     Push Function inside ` to stack
   ;        Push top element to stack
    1+      Add 1 to top element
       n    Run function x times (9 times)
        a   Invert stack

Ruby, 8 bytes

Seperated by newlines.

p *1..10

Perl 6, 12 bytes

say @(1..10)

The @() is needed to convert to an array

Alternative solution:

say @(^10+1)

Builds a range 0..10, then adds one, then converts to an array.

Mathematica - 13 bytes

Echo@Range@10

Saved 4 bytes thanks to MartinEnder!

Output: >> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Java 7, 53 51 52 bytes (loop)

void l(){for(int i=0;++i<11;)System.out.println(i);}

Alternative 51 bytes (hardcoded is shorter.., but considered a default loophole, so not allowed):

void h(){System.out.print("1 2 3 4 5 6 7 8 9 10");}

Alternative 54 bytes (recursive):

int i=1;void r(){System.out.println(i);if(i++<10)r();}

Ungolfed & test code for all three:

Try it here.

class Main{
  static void h(){
    System.out.print("1 2 3 4 5 6 7 8 9 10");
  }      

  static void l(){
    for(int i=0; ++i < 11;){
      System.out.println(i);
    }
  }

  static int i = 1;
  static void r(){
    System.out.println(i);
    if(i++ < 10){
      r();
    }
  }

  public static void main(String[] a){
    h();
    System.out.println();
    l();
    System.out.println();
    r();
  }
}

R, 4 characters

 1:10

The ":" is probably one of the most used R commands.

Fuzzy Octo Guacamole, 7 bytes

1.25*$:

Multiplies 2*5, takes the range of that and 1, and prints the whole stack.

1.25*$:
1.      # Push 1 to the stack and switch stacks
  25*   # Push 10 to the stack
     $  # Push every number in the inclusive range on the top of inactive stack and top of active stack ([1,2,3,4,5,6,7,8,9,10])
      : # Print the stack, which is a list containing the numbers.

><>, 13 bytes

01+:a)?;:nao!

Explanation :

01+:a)?;:nao!

0                 push initial value of n on the stack
 1+               increments n
   :              duplicates n on the stack
    a             push 10 on the stack
     )            pops n and 10 of the stack, push n>10 on the stack
      ?;          if n>10, stops program execution
        :n        duplicates n on the stack in order to display it
          ao      display 10 (x0A, linefeed)
            !     skips the next instruction, which since ><> loops is the push 0

You can see it in action on the online interpreter.

Python - 19 17 bytes

print range(1,11)

Saved 1 byte, thanks to KevinLau - not Kenny!

Output: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Dyalog APL, 3 bytes

⍳10

TryAPL online!

Groovy, 11 characters

print 1..10

Sample run:

bash-4.3$ groovy -e 'print 1..10'
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Haskell, 17 bytes

main=print[1..10]

Outputs [1,2,3,4,5,6,7,8,9,10].

PowerShell, 5 bytes

1..10

Creates a dynamic range with the .. operator from 1 to 10, then that array is left on the pipeline. Output is implicit. Default .ToString() method of an array is newline, so this will be newline-separated when run in a clean shell.

Sesos (binary), 5 bytes

Hexdump:

0000000: 2c4bbc 3301                                       ,K.3.

Try it online!

How it works

The binary file above has been generated by assembling the following SASM code.

Sesos is a language "based on brainfuck", but is "concise, can be typed easily, has somewhat flexible I/O, and is safe for work".

set numout    ;sets the output to printing a number per line,
              ;instead of characters.
add 10        ;now the tape is [10,0,...]
jmp           ;start of loop
              ;sets an entry marker and jump to the jnz instruction.
    fwd 1          ;forward the data head 
    add 1          ;add 1 to the cell under data head
    put            ;output (as number)
    rwd 1          ;rewind the data head by 1 cellby 1 cell
    sub 1          ;subtract 1 from the cell under data head
                   ;the tape goes from [0,10] to [1,9], to [2,8]
                   ;to ... [8,2] to [9,1] to [10,0] and then halts.
              ;(implicit jnz) end of loop, goto "jmp" if not zero

In brainfuck: ++++++++++[>+.<-] (assuming decimal output).

LOLCODE, 79 bytes

IM IN YR l UPPIN YR v TIL BOTH SAEM v AN 10
VISIBLE SUM OF v AN 1
IM OUTTA YR l

This code may need some tweaking depending on the compiler you're using. Some want you to add HAI/KTHXBYE, some want you to declare the variable ahead of time. One compiler breaks if your loop name is shorter than two characters, even though the loop name is never used.

Lua, 25 Bytes

for i=1,10 do print(i)end

Retina, 13 bytes

I've got two solutions at this byte count, but it doesn't seem optimal:

_10$*
1
$.`_

11$*_
\B
$.`

They both use _ as separators, prefix and suffix.

Try the first online! Or try the other one!

Brachylog, 6 5 bytes

Saved one byte thanks to @mat

10yb.

Try it online!

Explanation

10y        Get the list [0:1:2:3:4:5:6:7:8:9:10]
   b.      Output is that list minus the first element

Racket, 12 bytes

(range 1 11)

Prints '(1 2 3 4 5 6 7 8 9 10).

Julia 0.2, 11 bytes

print(1:10)

Pretty self explanatory. 1:10 is a range, and print expands it.

Dyvil, 22 bytes

for(x<-1..10)println x

23 bytes

for x<-1..10{println x}

Two ways to do the same thing: for-each loop over the range 1..10 with type-inferred loop variable x. The loop body calls the built-in println(int) function with the argument x.

24 bytes

println{for x<-1..10{x}}

This version calls the built-in println(AutoPrinter.()->void) method. An AutoPrinter instance is implicitly available to the {for ...} block, which is passed as an anonymous function. The AutoPrinter class has an applyStatement(any) method, which is called when an expression like x appears in a statement context. The implementation forwards to println(any), which prints the expression.

26 bytes

(1..10).forEach(println _)

Functional approach; creates an IntRange object and calls its forEach(int -> void) (higher order) method. The argument is an anonymous lambda function that passes the argument to the aforementioned println(int) method. In this case, println _ is syntactic sugar for the lambda expression x => println x. Again, the types are inferred by the compiler, so that it internally becomes (int x) => println x.

Output in all cases:

1
2
3
4
5
6
7
8
9
10

J, 6 bytes

1+i.10

Output: 1 2 3 4 5 6 7 8 9 10

Explaination:

1+       NB. Add one to...
  i.10   NB. A range from 0 to 9.