text:
Print numbers from 1 to 10
This might be a very simple challenge, but I am surprised it hasn't been done on code-golf yet:
Print all Integers from 1 to 10 inclusive in ascending order to standard output.
Your output format can be whatever your language supports. This includes arbitrary separators (commas, semicolons, newlines, combinations of those, etc., but no digits), and prefixes and postfixes (like [...]). However, you may not output any other numbers than 1 through 10. Your program may not take any input. Standard loopholes are disallowed.
This is code-golf, so shortest answer in bytes wins!
Leaderboard

var QUESTION_ID=86075,OVERRIDE_USER=42570;function answersUrl(e){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(e,s){return"https://api.stackexchange.com/2.2/answers/"+s.join(";")+"/comments?page="+e+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){answers.push.apply(answers,e.items),answers_hash=[],answer_ids=[],e.items.forEach(function(e){e.comments=[];var s=+e.share_link.match(/\d+/);answer_ids.push(s),answers_hash[s]=e}),e.has_more||(more_answers=!1),comment_page=1,getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:!0,success:function(e){e.items.forEach(function(e){e.owner.user_id===OVERRIDE_USER&&answers_hash[e.post_id].comments.push(e)}),e.has_more?getComments():more_answers?getAnswers():process()}})}function getAuthorName(e){return e.owner.display_name}function process(){var e=[];answers.forEach(function(s){var r=s.body;s.comments.forEach(function(e){OVERRIDE_REG.test(e.body)&&(r="
"+e.body.replace(OVERRIDE_REG,"")+"
")});var a=r.match(SCORE_REG);a&&e.push({user:getAuthorName(s),size:+a[2],language:a[1],link:s.share_link})}),e.sort(function(e,s){var r=e.size,a=s.size;return r-a});var s={},r=1,a=null,n=1;e.forEach(function(e){e.size!=a&&(n=r),a=e.size,++r;var t=jQuery("#answer-template").html();t=t.replace("{{PLACE}}",n+".").replace("{{NAME}}",e.user).replace("{{LANGUAGE}}",e.language).replace("{{SIZE}}",e.size).replace("{{LINK}}",e.link),t=jQuery(t),jQuery("#answers").append(t);var o=e.language;/s.lang?1:e.lang<s.lang?-1:0});for(var c=0;c<t.length;++c){var i=jQuery("#language-template").html(),o=t[c];i=i.replace("{{LANGUAGE}}",o.lang).replace("{{NAME}}",o.user).replace("{{SIZE}}",o.size).replace("{{LINK}}",o.link),i=jQuery(i),jQuery("#languages").append(i)}}var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe",COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk",answers=[],answers_hash,answer_ids,answer_page=1,more_answers=!0,comment_page;getAnswers();var SCORE_REG=/<h\d>\s*([^\n,]*[^\s,]),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/,OVERRIDE_REG=/^Override\s*header:\s*/i;
body{text-align:left!important}#answer-list,#language-list{padding:10px;width:290px;float:left}table thead{font-weight:700}table td{padding:5px}
 <link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">

Leaderboard

	Author	Language	Size

Winners by Language

Language	User	Score

{{PLACE}}	{{NAME}}	{{LANGUAGE}}	{{SIZE}}	Link

{{LANGUAGE}}	{{NAME}}	{{SIZE}}	Link

Related (duplicate?)

Not exactly duplicate, this doesn't take input

If the only change is hard-coding a single parameter then that falls under the banner of "trivial change", and by the standards of this site still counts as a dupe.

@PeterTaylor The other challenge has a huge problem with the integer limits though. The way it's specified every TC language that doesn't have 64-bit integers needs to implement them. (And that affects quite a lot of languages.)

@MartinEnder It's too bad the other question has the silly limitation, but I still think it's a dupe when one can port over 2/3 or more of the answers with only minor modification.

@xnor Quite frankly, I'd rather close the other challenge as a duplicate of this one. The requirement pretty much ruins it.

I dislike the other challenge's requirement, but it's not something that we could (or should) close it for. As it stands this is a dupe of the other, more general challenge.

Is it forbidden to print any number other than the 1 to 10?

I can't believe every single of the (currently) 71 answers assumes the base should be decimal…

Does a click on "OK" qualify as separator and suffix?

@SkippyleGrandGourou Hehe, that's brilliant. Just a simple output of 1 10 would suffice in base-2. xD

Could you clarify whether having no delimiter at all is allowed, too? I.e. 12345678910?

Could you please add a leaderboard snippet? 100+ answers is a lot to sift through manually.

There are languages which are so verbose that it's worth considering whether hardcoding a string consisting of all 10 numbers is shorter than actually writing a loop. Is that intentional?

Cheaty-as-heck answer: do 1111111111 and argue that it printed all numbers from 1 to 10 in unary

The "Winners by Language" section is not working

Do we have to print delimiters? May I print a leading or trailing delimiter?

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

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

There's no mention of being able to pass in parameters to the function.

@AshBurlaczenko What are you talking about? This is a standard technique in golfing to initialise an int to 1. You don't need to pass any command line arguments. In fact, doing so will cause the program to produce the wrong output.

@AshBurlaczenko By consensus we have agreed that programs may assume they will not be called with unnecessary input (in this case, no additional command line arguments, beyond the program itself). That means i here will always be 1 when this program is run. Did you mean something else?

Sorry, I've not written C but assumed it's default value would be 0 as in every language I've used.

@AshBurlaczenko In C, the first argument to main is the number of command line arguments (including the executable name itself). Since no additional arguments are passed, that count is 1. The second argument to main is the actual list of command line arguments, but that argument is ignored in this program.

@MatthewRoh +1 for the +1 about that part :)

@ChrisBouchard argc (or i here), could be zero in 1) non-hosted environments 2) when a program is called with exec() and specifies 0.

HTML, 44 bytes

This is longer than hardcoding the output, but it is more interesting this way. It creates an ordered list (
) with ten empty list elements (
). By default ordered lists are delimited by decimal numbers starting with 1 and a period.
HTML5 is very forgiving regarding unclosed tags, so it closes the li tags implicitly.

+1 for abusing HTML5's forgivingness (?).

Cold-blooded.  I love it.

Actually, NinjaBearMonkey and @HyperNeutrino, this isn’t “forgiveness” per se; HTML5 is pretty explicit about which tags are allowed to be left unclosed. It’s just that lists and list items are two that are.

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

Last one is just seq/coreutils, bash not involved.

@hyde: Without bash the call to seq wouldn't be possible, would it?

In my vision, if we leave out bash, then seq would be the interpreter. But then 10 is a valid program in “seq” language?

Never try this at your console: echo {1..1000000000}
If you curious, do with your own risk.

@Brain90, there is no danger on my poor 8Gb RAM machine. ;) “bash: brace expansion: failed to allocate memory for 1000000000 elements”. At least with bash 4.3.46.

@manatwork, sorry for the mistake. I execute this
$ echo {1..100000000000000} -> 14 digits zero.
LED storage indicator goes crazy, and hang. 4Gb RAM.

@manatwork seq is not a programming language per the consensus definition here. https://codegolf.meta.stackexchange.com/questions/2028/what-are-programming-languages/2073#2073

@Sparr, didn't claimed it is. Is a “function” defined in one of the shell's “libraries”.

@manatwork "then seq would be the interpreter. But then 10 is a valid program in “seq” language?" <-- seq is not a language or an interpreter of a language.

Is the 10c version allowed as there're extra string in front of and behind

@l4m2, the challenge text explicitly allows arbitrary separators, prefixes and postfixes. I agree, that is probably not what the challenge author intended to say by allowing “etc., but no digits”. That is why although my solution not literally violates the requirement, I posted it only as a funny alternative.

Seen that part . sorry

The ls version doesn't work for me (on macOS 11.6), it prints 10 before it prints 2.

Jelly, 2 bytes
⁵R

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

⁵R, two bytes

Why on Earth would someone invent a language in which a command returns either the fifth argument or the integer 10?..

@AndreïKostyrka Because Dennis

Is there an encoding where ⁵ is just one byte? Since it's 3 bytes in UTF-8, the length of the program should be 4 bytes.

@RadovanGarabík Jelly uses its own codepage

05AB1E, 2 bytes
Code:
TL

Explanation:
T   # Constant for 10
 L  # Range

Try it online!.

When I saw this, I felt the need to say "tl;dr". :P +1, by the way.

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

Try it online!

Beat me to it, and shorter too, will post mine anyway as I don't think we've used the same trick. Have my +1 :)

I was close with 67 bytes, but not close enough: ++++++[>++++++++<-]>>>++++++++++[-<+<<+>>>]<[-<.+<.>>]<<-[>-<-]>.-.

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.

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!

i like the smileyface. (Isn't there an error in your explanation: A, creates a list from 0 to 9)

R, 4 bytes
2:10

The ":" is probably one of the most used R commands. Improvement by Barranka in comments.

Should they require printing a string, not returning a vector, consider cat(1:10).

Is there a leading whitespace?

Given that the output is [1]  1  2  3  4  5  6  7  8  9 10, maybe it would be better 2:10, which will output [1]  2  3  4  5  6  7  8  9 10

@Clashsoft, that was a mistake - thank you. And yes, Barranka, good point - upvoted.

Uh?! The requirement is "Print all Integers from 1 to 10", not from 2.

Come on, Prof. Robert, read the comment by Barranka :-)

Ruby, 8 bytes
Separated by newlines.
p *1..10

*Separated by newlines.

You can do that?

@DmitryKudriavtsev yes, the star causes the code to break down to p 1,2,3,4,5,6,7,8,9,10 and commas cause p to separate them by newlines.

OK. I didn't think that the operator has a lower precedence than range.

JavaScript (ES6), 29 bytes
alert([...`${1e11/81^14}`]+0)

Outputs 1,2,3,4,5,6,7,8,9,10. Not the shortest answer but I thought it was a fun calculation.

why not alert([...'1'+234567891]+0)

@edc65 a) it's not as fun b) it's not as short as the previously posted JavaScript answer c) it's not even as short as alert([...'1234567891']+0).

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.

Ninja'd by seconds :/

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

Output
1 2 3 4 5 6 7 8 9 10

Try it online.

Nice! – – – – –

Mathematica - 13 bytes
Echo@Range@10

Saved 4 bytes thanks to MartinEnder!
Output: >> {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

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

Welcome to Programming Puzzles and Code Golf!

DC, 12 bytes
...a little bit mean now...
[zzpA>L]dsLx

Unrolled:
[   # start string constant
z   # push stack length (0 on 1st cycle)
z   # push stack length (1 on 1st cycle)
p   # print top of stack
A>L # if 10(decimal) < tos: execute L
]   # end string constant, push it
d   # duplicate the string
sL  # store a copy in L
x   # execute tos (which is the other string copy)

One of the z (push stack length) operations has no corresponding operation which takes it from the stack. This way the stack grows with each iteration by one. This is abused as the loop counter.
This loop starts with an empty stack, so the 1st z pushes 0 in the 1st iteration so the printing happens after the 2nd z which correspond to duplicating the result of 1+d in the version below. This way the comparison needs to test for bigger than 10 here instead of bigger than 11 below.

DC, 14 bytes
Just straight forward...
1[p1+dB>L]dsLx

Unrolled:
1   # push 1
[   # start string constant
p   # print top of stack
1+  # add 1 to tos
d   # push tos (duplicate)
B>L # if 11(decimal) < tos: execute L
]   # end string constant, push it
d   # duplicate the string
sL  # store a copy in L
x   # execute tos (which is the other string copy)

I wish you'd explain these =(

@EvanCarroll — Writing dc programs is easier than explaining. But I tried... ;-)

MATL, 3 bytes
10:

Try it online!
The code generates the vector [1 2 ... 10] and implicitly displays it, with the numbers separated by spaces.

><>, 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.

Could you please add an explanation?

Run the program nao!

@Cyoce ><> is great to write enthusiastic pieces of code, I've got this motorcycle gear checker answer in the same vein ;)

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.

For Perl 5.10, 14 bytes and almost like yours: say for(1..10)

@PaulPicard do post it! Perl 5 is a different language.

Can you remove the space for say@(1..10)?

@Cyoce alas no, it's an error.

10 bytes: say 1...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.

Vim, 12 bytes
i1<Esc>qqYp<C-a>q8@q

Outputs
1
2
3
4
5
6
7
8
9
10

Explanation:
i1<Esc>qqYp<C-a>q8@qZZ
       qqYp<C-a>q      -- Macro q: duplicate line and increment (6)
i1<Esc>                -- Insert 1 (3)
                 8@q   -- Run macro q 8 times (3)

Tested on Neovim 0.1.4, which to my knowledge is keystroke-compatible with Vim.

Nice. I came up with iYp<C-v><C-a>1<Esc>d^9@-ZZ. Same byte count.

Shorter. :)

Haskell, 17 bytes
main=print[1..10]

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

I'm a bit confused here... I'm almost certain that it should be [1..10]. I don't have access to a haskell compiler, but I'll double-check in the morning.

@Zwei Ranges don't include their upper limit in Haskell.

@C.Quilley They totally do. You might be thinking of Python.

Huh, I was sure I had tested this code. Apologies for the earlier assertion.

I don't think you need the main= part; the rest has the type of a haskell program, IO (). Correct me if there is a specific ruling against this.

@Lazersmoke True, you could save 5 bytes. (Others, see here if not sure)

Dyalog APL, 3 bytes
⍳10

TryAPL online!

too long.........

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.

My thought was >:i.10, but that's the same thing.

MarioLANG, 34 27 25 bytes
+<
:"
+
:
+
:
+
:
+
:!
=#

Try it online!
Thanks to Jo King for -7 -9 bytes!
code:
Mario falls down, incrementing and saying his number five times,
then he steps on the elevator, rides up and falls down again,
incrementing and saying his number another five times.
Then he walks left and falls out of the code.
14 bytes shorter than the easy way:
39 bytes
+:+:+:+:+:+:+:+:+:+
==================:

Try it online!

Thank you. Sometimes you just can't see the forest for the trees.

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();
  }
}

EDIT: For funsies: As correctly pointed out by @SkippyLeGrandGourou, the base of the 1 to 10 isn't specified in the question, so here is (non-code-golfed) Java code that outputs 1 to 10 in the bases 2 to 10:
Try it here.
BASE-2: 1 10
BASE-3: 1 2 10
BASE-4: 1 2 3 10
BASE-5: 1 2 3 4 10
BASE-6: 1 2 3 4 5 10
BASE-7: 1 2 3 4 5 6 10
BASE-8: 1 2 3 4 5 6 7 10
BASE-9: 1 2 3 4 5 6 7 8 10
BASE-10: 1 2 3 4 5 6 7 8 9 10

Loop can be for(int i=1;i<11;)System.out.println(i++), saves one byte.

@zyabin101 Changed the order so the hard-coded answer is non-competing. Still left it in the answer though, since it's pretty funny (and sad) that hard-coded is the shortest way to print 1-10 in Java 7..

@zyabin101 Except when the question is tagged [tag:kolmogorov-complexity].

@Neil Oh, right. o_o

Java 8's the clear winner here thanks to lambdas! ()->java.util.stream.IntStream.range(1,11).forEach(System.out::println). Why you say it's longer? It's Java 8... Java 8 is shorter by default! I didn't even put braces before and after the code! I can even count to 98 without getting an extra character! See? Java 8 rules!

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.

PostScript, 12 bytes
1 1 10{=}for

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

(Most PostScript interpreters don't actually have a proper stdout, or even a command line, but GhostScript has both and can be used to run this program.)

Aussie++, output to STDERR, 29 28 bytes
It turns out that causing errors is shorter than any straightforward way of doing it.
G'DAY MATE! 1 2

4

6

8

_

Tested in commit 9522366. The trailing newline is required. Produces the following errors:
[line 1] OI MATE! EXPECTED ; BUT GOT '2'
[line 3] OI MATE! EXPECTED ; BUT GOT '4'
[line 5] OI MATE! EXPECTED ; BUT GOT '6'
[line 7] OI MATE! EXPECTED ; BUT GOT '8'
[line 9] OI MATE! EXPECTED ; BUT GOT '_'
[line 10] OI MATE! EXPECTED ; BUT GOT 'EOF'

Maybe I misinterpreted the challenge, but it didn't specify that you had to use the same separator for all numbers.
Aussie++, output to STDERR with consistent separator, 30 bytes
G'DAY MATE!;
;
;
;
;
;
;
;
;
;

No trailing newline is required. Produces the following errors:
[line 1] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 2] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 3] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 4] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 5] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 6] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 7] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 8] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 9] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'
[line 10] EXPECTED NUMBER, STRING, BOOLEAN, NIL, OR IDENTIFIER BUT GOT ';'

Aussie++, output to STDOUT, 41 bytes
G'DAY MATE!
GIMME "1 2 3 4 5 6 7 8 9 10";

Again, no trailing newline is required.

Python2 - 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]

Use range instead of xrange, assuming Python 2. In fact, this current version doesn't seem to work on my machine in either Python version.

@KevinLau-notKenny I could've sworn that I tried that, and got nothing to STDOUT. Thanks!

Important: It's only Python 2

@MegaMan You're right. I just felt leaving it out, since almost every other Python2 answer does that. I'll edit the title.

Please see my first answer on the site, it is in Python3 :D

@ABcDexter I checked it out, very nice! The reason I didn't use Python3, was because I was forced to cast the range object that returns an iterator, to a list.

@TuukkaX Yes, exactly. I'll try some other languages too. Thanks :).

@TuukkaX: You don't need to cast, but it would be a titch longer in Py3: print(*range(1,11))

@ShadowRanger Yup, my bad. ABcDexter already submitted that Py3 snippet :P

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!

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).

PHP, 25 23 bytes
Saved 2 bytes thanks to manatwork.
 <?=join(_,range(1,10));

Creates an array of [1 .. 10] and echoes the values separated by _s.

You could take advantage of the freedom to choose the separator. Using “_” as Martin Ender's Retina solution does would reduce the length by 2. (At the obvious price of an undefined constant notice, which is fine as PHP's suggested production configuration not displays notices anyway.)

@manatwork: That is very strange, I had no idea that was even possible. Thanks for the suggestion!

Same length: for(;$i++<10;)echo$i,_;

@IsmaelMiguel: That's longer because it requires the full <?php and not just <?=

@BusinessCat Not exactly. It is meant to be executed using the -r argument. And the -r argument is free

Short open tags are still valid and still on by default; they only removed <%, <%= and Code: <textarea id="txtCode" type="text" class="textBox" style="height: 200px">[[[[[[[[[[.,][.].,][.].,][.].,][.].,][.].,][.].,][.].,][.].,][.].,]</textarea>
Input: <textarea id="txtInput" type="text" class="textBox"></textarea>
<input id="btnInterpret" type="button" value="Run" />Output as: <select id="lstOutputAs"><option value="">Number array</option><option value="true">String</option></select>
Result:

Grok, 13 bytes
}q
{p1+YzP9>!

Vyxal, 2 bytes
₀ɾ

Try it Online!
Explanation:
₀   # 10
 ɾ  # Range [1, N]
    # Implicit output

BRASCA, 9 bytes
1lr,[nlo]

Try it!
Explanation
1lr         - Push range(1,10) to the stack
   ,        - Reverse the stack
    [   ]   - While the stack isnt empty:
     n      -   Output the next number...
      lo    -   and a newline!

CSASM v2.4.0.2, 43 bytes
func main:
push [1..10]
conv ~arr
print
ret
end

Prints [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ] to the console.
Explanation:
func main:
    ; Push a Range
    push [1..10]
    ; Convert it to an array: [1..10] -> [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
    conv ~arr
    ; Print the CSASM representation of that array
    print
    ret
    end
end

If the output had to only be the numbers 1 through 10, that would be this 72 byte program:
func main:
lda 1
.lbl a
push $a
print.n
inc $a
push 11
push $a
sub
brtrue a
ret
end

Explanation:
func main:
    ; Store 1 into $a
    lda 1

    .lbl a
        ; Print $a
        push $a
        print.n

        ; Stop looping if 11 - ++$a == 0
        inc $a
        push 11
        push $a
        sub
        brtrue a
    ret
end
```

Hexagony, 16 bytes
9{$:':</)!'/>;}}

Try it online!
Expanded:
   9 { $
  : ' : <
 / ) ! ' /
  > ; } }
   . . .

Admittedly, this solution feels a bit questionable. Its output is
123456789	10
This is each number from 1 to 10, separated by the Unicode characters of their values. So, for example, 9 and 10 are separated by tab, which is Unicode character 9. Technically the problem doesn't specify that all the separators must be the same, though perhaps its implied. If you feel this is invalid, here's a 17 byte version that uses lowercase e as a separator (nothing special about e, it can be any character that isn't a special character in Hexagony).
9{.e:'<)!'://}};>

Here's another 17 byte alternate that prints the numbers separated by newlines, but never terminates (it prints 1 to 10 and then runs forever without printing anything else).
_10<>-<{)!'//=;{>

I'll just explain the 16 byte code because the others are just minor variations on it. Starting in the top left and moving right, 9}$ writes nine into a memory slot, then moves to an adjacent memory slot, and uses $ to jump into the main loop on line 3. The main loop starts with )!, which increments the
value in the current memory slot and then prints its decimal value. This cell will cycle through the values 1 to 10, printing each. Then, ': backs up to a new memory slot and divides 9 by the number that was just printed. Because Hexagony uses integer division, the result will be one as long as the number is less than or equal to 9, and 0 once its greater. This gives a termination condition, as another ': backs into an empty slot and divides 0 by this number. As long as this value as 1 this calculation will be inconsequential, but when it equals zero, the program will crash trying to divide by zero. After this, }}; moves back to the incrementing memory slot, prints it as a Unicode value, and then reenters the main loop.

Welcome to Code Golf, and nice first answer! IMO "Your output format can be whatever your language supports. This includes arbitrary separators" means that this format is perfectly acceptable, but if you're really concerned, you can leave a comment below the question asking once you've reached 50 reputation. I've edited your answer to include the unprintable characters

@cairdcoinheringaahing Ah cool, thanks!

Knight, 16 bytes
;=w 0W>10wO=w+1w

Try it online!
# set w to 0
; = w 0
# loop while w < 10
: WHILE > 10 w
   # Output ++w
   : OUTPUT (= w + 1 w)

Japt, 2 bytes
Aõ

Test it
Aõ
A     :10
 õ    :Range [1,A]

Swift 5.6, 18 bytes
print([_](1...10))

SwiftFiddle link, since TIO uses Swift 5.0.
Same method as this Swift 3 answer, but using a new syntax for type inference. [Int] is short for Array<Int>, and Array<_> means "an array, but infer the element type" (mostly the same as just Array). Therefore, [_] is short for Array. Go figure.

Python 3, 24 19 bytes
print(*range(1,11))

Explanation:
       range(1,11)  # numbers 1 to 10
      *             # splat to print
print(            ) # print the numbers out

Piet + ascii-piet, 24 bytes (3×9=27 codels)
utqrnFecnnneutMj?lkad mm

Try Piet online!

Outputs ?1?2?3?4?5?6?7?8?9?10 where each ? is \x08. Uses 8 as the separator and the test to leave the loop (>8).
The position of the arrow is a little weird, but it starts at the top left corner facing right. Since the stack is initially empty, the first loop has a bunch of no-ops at random places, and the separator itself is on the stack when it hits DP+ the first time. If the separator is 9, then it goes to the exit path right away.
+ dup dup outN    [] no-ops
4 dup + dup outC  [8] print ascii 8
>                 [8] no-op
DP+               [] keep in the direction because 8 % 4 == 0

1 + can be used as a pattern to initialize the loop with a 1 and increment each loop.
1 +           [n] start loop with a number
dup dup outN  [n n] print n as a number
4 dup +       [n n 8]
dup outC >    [n n>8] print ascii 8 and make a boolean
DP+           [n] turn to the exit path if n > 8 (after 9 is printed)

Now we can print 10 and exit.
roll      [9] no-op; dummy cmd due to fixed colors
1 + outN  [] print 10 and exit

I tried to think of some dark magic approaches like "divide the number by 5, use DP+ at the lower left corner and end the program at the lower right corner" (since DP+ 0 and 1 would lead back to the start while 2 would reverse the pointer direction), but I couldn't get it to work.

Regenerate -a, 8 bytes
[1-9]|10
Attempt This Online!

Cognate, 16 bytes
Print Range 1 11

Attempt This Online!
Pretty self-explanatory, but here's a fuller version:
Print the Range of numbers from 1 up to but not including 11

(Lowercase words are treated as comments.)

Nibbles, 1.5 bytes (3 nibbles)
,10

Program saved on disk conists of the 3 hex nibbles d1f:
d = , literal code = range 1..
1 = encode integer
f = integer value 10

Note that Nibbles appends a 6-nibble, not part of the program code, to pad the saved file to a whole number of bytes.

Labyrinth, 14 bytes
9:"
 ("
!)
\"@

Try it online!
Prints 1 to 10 separated and terminated by newlines.
9    Push 9

:"   Loop in the order of : ( " "
("   duplicate, decrement; exit if top is 0 at (
     [9 8 7 6 5 4 3 2 1 0 | ]

!)   Loop in the order of ) ! \ "
\"   increment, print, print newline; exit if stack is empty at "

@    Halt

Labyrinth, 14 bytes
 "):
 \ !
@%0#

Try it online!
Prints 1 to 10 separated by newlines. This was the only loop I found that fits in 8 commands, which puts the halt command at a costly position.
"):   Loop in the order of " ) : ! # 0 % \
\ !   increment (pushes 1 if empty); duplicate; print;
%0#   push stack height (1); multiply by 10; mod (change 10 to 0);
      print newline
      exit at % when the number becomes zero
@     Halt

Bc, 14 characters
while(i++<10)i

Sample run:
bash-4.3$ bc <<< 'while(i++<10)i'
1
2
3
4
5
6
7
8
9
10

Batch, 35 bytes
@for /l %%i in (1,1,10)do @echo %%i

Hardcoding would have saved 10 bytes...

you can cut the CR/LF to save two bytes.

@peterferrie But there is no CR/LF...

Bubblegum, 17 bytes
00000000: 026f eafc 0f98 211e 5d50 d0aa 25bc 6f2a  .o....!.]P..%.o*
00000010: d1                                       .

Outputs 1 2 3 4 5 6 7 8 9 10. The program is compressed using BB96, whereas other schemes are longer due to compression-format headers.

Pyke, 2 bytes
TS

Try it here!
one_range(10)

ListSharp, 37 bytes
[FOREACH NUMB IN 1 TO 10 AS i]
SHOW=i

Pretty straight forward
as a sidenote =>
is this cheating?
SHOW="10,9,8,7,6,5,4,3,2,1"

Hardcoding the output is a standard loophole.

"Often, this vulnerability is an indicator of a dumb question"

@Neil, except [tag:kolmogorov-complexity].

Racket, 15 bytes
(cdr(range 11))

Racket's interpreters implicitly print return values of expressions to standard output, which is nice.

Lua, 26 bytes
for i=1,10 do print(i) end

Prints them in seperate lines.

Duplicate of Katenkyo's answer posted ~9 hours earlier.

Excel VBA, 47 Bytes
Sub t()
For i = 1 To 10: MsgBox i: Next
End Sub

You can lose 9 bytes by condensing your whitespace down and removing the () following Sub to Sub t
For i=1To 10:MsgBox i:Next
End Sub

Scala, 14 bytes
print(1 to 10)

output
Range(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

Minecraft 26
say "1 2 3 4 5 6 7 8 9 10"

I know there is no special clue in it but I don't know.
Real answer:
scoreboard objective add a dummy

Repeating
give @p wool
stats entity @p set AffectedItems a @p
scoreboard player set @p a 0
clear @p wool 0 0
tellraw @p {"selector":"@p","objective":"a"}

IIRC you don't need the quotes when using the say command. But this is not relevant, because your answer with the say command is invalid anyway, because hardcoding the output is a standard loophole everywhere other than at [kolmogorov-complexity] challenges. See http://meta.codegolf.stackexchange.com/a/1063/29672

@CocoaBean This IS [tag:kolmogorov-complexity]

Racket, 12 bytes
(range 1 11)

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

Befunge, 14 * 3 - 1 = 41 bytes
0v          <
 >:1+::.55+-|
            @

Quick and dirty befunge '93 solution. I'm sure it could be improved, maybe I'll look into it tomorrow. 41 bytes is the 14 * 3 grid in total, excluding a final newline, there are actually 16 characters in the source.

Go, 73 bytes
package main
import "fmt"
func main(){for i:=1;i<11;i++{fmt.Println(i)}}

Try it online!

Hello, and welcome to PPCG! This is a great first post.

Normally, we use a header like I edited in with the number of bytes in your submission.

Element, 13 bytes
10'[1+2:`\
`]

Try it online
This outputs one number per line with a trailing newline.  This can be shorted to 12 bytes if I replace the newline with a letter (like the letter x).  It works by creating a FOR loop, which repeatedly increments the top of the stack, duplicates it, and outputs it.

Nice! You're in your element! :D

JS, 75 Bytes

a=[0,1,2,3,4,5,6,7,8,9,10]; for(a[0];a[0] 9
      #       Skip the next character, which would otherwise stop the program
        _     Is the number in the top of the stack true (i.e. not 0)?
       @      If yes, stop the program
         1+   If no, add 1 to the top of the stack
           #  Skip the next character. Since we're at the edge of the program,
              it would wrap to the beginning, so the character being skipped is
              the "1" at the left edge. That is, "don't put 1 on the stack again"

10 bytes

Maple, 10 bytes
seq(1..10)

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

F# 17 bytes
Equal to Haskell !! yuppee.
printf"%A"[1..10]

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

For each number on a separate line, 28 bytes:
Seq.iter(printfn"%d")[1..10]

If you remove the standard output permission, simply [1..10] prints out the numbers in F# interactive.
[1..10];;
> val it : int list = [1; 2; 3; 4; 5; 6; 7; 8; 9; 10]

Linux ASM, 52 Bytes
file format elf32-i386

Disassembly of section .text:

08048060 <_start>:
 8048060:   31 c9                   xor    ecx,ecx
 8048062:   31 db                   xor    ebx,ebx
 8048064:   31 d2                   xor    edx,edx
 8048066:   31 ff                   xor    edi,edi
 8048068:   43                      inc    ebx
 8048069:   66 81 c7 20 31          add    di,0x3120
 804806e:   57                      push   edi
 804806f:   89 e7                   mov    edi,esp
 8048071:   42                      inc    edx
 8048072:   42                      inc    edx
 8048073:   83 c1 0a                add    ecx,0xa

08048076 <loc_16h>:
 8048076:   87 cf                   xchg   edi,ecx
 8048078:   31 c0                   xor    eax,eax
 804807a:   83 c0 04                add    eax,0x4
 804807d:   83 ff 01                cmp    edi,0x1
 8048080:   75 08                   jne    804808a <loc_2ah>
 8048082:   c7 04 24 20 31 30 ff    mov    DWORD PTR [esp],0xff303120
 8048089:   42                      inc    edx

0804808a <loc_2ah>:
 804808a:   cd 80                   int    0x80
 804808c:   66 ff 41 01             inc    WORD PTR [ecx+0x1]
 8048090:   87 cf                   xchg   edi,ecx
 8048092:   e2 e2                   loop   8048076 <loc_16h>

golflua, 13 characters
(Rewrite of Katenkyo's Lua answer. Appreciations should be expressed by upvoting the original answer.)
~@i=1,10w(i)$

Sample run:
bash-4.3$ golflua -e '~@i=1,10w(i)$'
1
2
3
4
5
6
7
8
9
10

Verbosy 31 Bytes
~0 /0 ~10 /1 :a: ^0 o \0 -1 >-a

Verbosy is a language that I wrote btw. The explanation can be found in README.md.

JavaScript, 30 bytes
for(i=0;i++<10;)console.log(i)

But I still love it that good old for beats all the pretty ES versions:
[...Array(10)].map((_,i)=>console.log(i+1)) 43 Bytes
alert([...Array(10)].map((_,i)=>i+1)) 37 Bytes
alert(Array(10).fill().map((_,i)=>i+1)) 39 Bytes
i=[...Array(11)].keys();i.next();alert([...i]) 46 Bytes
alert([...[...Array(11)].keys()].slice(1)) 42 Bytes
alert([...Array(11).keys()].slice(1)) 37 Bytes

why do you need the |0 in the second functional solution?

@Paolo Bonzini: not needed ... copy&paste leftovers

Someone already did this, although they used alert instead of console.log.

@Neil: Thought I had browsed all answers. Can you link it?

@Titus It was one of the first ;)

Actually I thought about replacing console.log with alert, but see my comment on the question.

LOLCODE, 67 55 bytes
VISIBLE 1 AN 2 AN 3 AN 4 AN 5 AN 6 AN 7 AN 8 AN 9 AN 10

VISIBLE "1 2 3 4 5 6 7 8 9 10" is only 30 bytes.

Oh wow. i'm dumb.

I can't do that exactly though because the challenge is to print integers, not strings.

Is there any difference in the result?

Not to the user reading the output, but to the compiler yes.

Alright, it's a loophole anyway.

This is [tag:kolmogorov-complexity] which is an exception to the loophole, right?

wait...

I don't know, people here seem to avoid that loophole.

@OldBunny2800 Correct.

JavaScript with UnderscoreJS, 20 Bytes
alert(_.range(1,11))

A similar solution was posted here. Posting a comment suggesting a byte improvement may be a good option next time :)

That´s not one byte, that´s 50%.

JShell (Java 9), 37 36 bytes
for(int i=1;i<11;i++)printf("%d ",i)

Java 9 has a REPL called JShell. You'll need an early access build of Java 9 to run it. Once it's installed, just run jshell, paste, and voilà !
Realized after looking at other solutions that newlines aren't a requirement. Saved 1 byte.

Brainfuck, 34 bytes
With input checkbox checked.
,.>,-.>++++++++[<<+.>.>-],.-.!1!1

Output
1 2 3 4 5 6 7 8 9 10

I don't think this challenge is supposed to take input.

Are you sure this is a correct solution? The code isn't supposed to take input at all, something that the ! suggests.

Kona, 5 bytes
Code:
1+!10

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

ROOP, 15 bytes
123456789
h(10)

Solution with hardcoded numbers, I'm still trying to find a shorter program.
In this language each digit becomes an individual object. Number 10 is written in parenthesis to make it a single object. The operator h prints all objects that are currently in the program, separated by a space, then halt.

seems that 7 is missing

@roblogic wow, you are right, fixed.

GolfScript, 5 bytes
11,(;

Try it online!

The official interpreter produces no whitespace (or comma) between the values.

CoffeeScript, 19 characters
console.log [1..10]

Sample run:
bash-4.3$ coffee -e 'console.log [1..10]'
[ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]

On-line test

MoonScript, 17 characters
(Rewrite of Katenkyo's Lua answer. Appreciations should be expressed by upvoting the original answer.)

for i=1,10print i

Sample run:
bash-4.3$ moon <(echo 'for i=1,10print i')
1
2
3
4
5
6
7
8
9
10

TI-BASIC, 9 bytes
seq(X,X,1,10

TI-BASIC is tokenized, so seq( is represented as 1 byte, as are all the other characters. The seq function is actually more powerful: the first X is an expression, and the second X is the variable that is used in the expression using the values 1 to 10, instead of using the predefined variable for X. For example, the squares of the numbers from 1 to 10 would be seq(X²,X,1,10.

JavaScript, 31 bytes
for(i=1;i<11;i++)console.log(i)

Just a for loop that prints the number on every execution. The range of the for loop is 1 to 10.

This is essentially the same as another answer.

Clojure, 20 bytes
(print (range 1 11))

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

C++ : 67 bytes
#include<iostream>
int main(int i){for(;i<11;std::cout<<i++<<",");}

Output:

1 2 3 4 5 6 7 8 9 10

I think it would be enough to just count the pure code without the main function and the include, the C# solution also didnt do it http://codegolf.stackexchange.com/a/87419/53809

VIM, using Bash and coreutils: 9 bytes
:!seq 10

Technically this is 10 bytes because you need to hit <CR> for the command to work.

@DJMcMayhem Good point. However, it does not need <CR> for the command to work if the command is passed to vim from the shell vim -c ':r!seq 10'. Of course one has to hit <CR> to execute the command from the shell, but this is then 'technically' not part of the vim command. Slightly different, but one could even argue that a C program without a newline wouldn't be valid either link.

Actually, if you were to take that approach, you wouldn't even need the colon, so it could be 8. I think technically that would be a vimscript answer (or ex?), rather than vim. You could post that as a separate answer I suppose

It can be even reduced to 7 bytes, if you only care about displaying the numbers 1 to 10. Then the r can be omitted too.

K,  5 Bytes
    1+!10
1 2 3 4 5 6 7 8 9 10

Explanation;
!2    --> 0 1
!5    --> 0 1 2 3 4
!10   --> 0 1 2 3 4 5 6 7 8 9
1+!10 --> 1 2 3 4 5 6 7 8 9 10

C#, 54 bytes
n=>{for(int i=1;i<11;)System.Console.Write(i+++" ");};

Only one byte shorter than n=>{System.Console.Write("1,2,3,4,5,6,7,8,9,10");};. Silly C#!  Edit: Actually, if I take out the spaces VS added, this comes in at 51...

@BMac Yeah but solutions like that are no fun! And with the above I could pass I  through as an argument and force it to 1 saving 4 bytes and probably some other changes :) On second thoughts that's disallowed so no I can't do that

RETURN, 7 bytes
1{11
}.

Try it here.

Fourier, 12 bytes
Prints a leading newline
10(10aX^o~X)

Try it online!

GNU sed, 22 21 bytes
c1 2 3 4 5 6 7 8 9 10

With coreutils, the code is only 7 bytes long!
eseq 10

Adding to the diversity of languages used so far, I present a sed solution. The consensus is that sed is exempt from the "no input" rule, since the script doesn't start without.
Run:
echo | sed -f script.sed

Silicon, 3 bytes
(Silicon uses CP037, so 3 bytes, not 4.)
0Â\

Explanation:
0Â\
  \     Push a list with the numbers in the range...
0       Zero
 Â      Ten

Seriously/Actually, 3 bytes
9uR

Try it online: Seriously, Actually
Explanation:
9uR
9u   push 9, increment (10)
  R  range(1, 11) ([1, 2, 3, 4, 5, 6, 7, 8, 9, 10])

Java 7, 50 bytes
void m{for(int i=1;i<11;System.out.println(i++));}

Welcome to Programming Puzzles & Code Golf! Just so you know, the downvote was cast automatically by the Community user when your answer was edited. I consider this a bug. I'd upvote, but I don't know Java and have no idea how to test your code. Could you maybe include a link to an online interpreter?

APL, 3 bytes
⍳10

Explanation:
⍳   range
10   10

Of course, your ⎕IO must be 1.

@ZacharyT Which is its default value

Depending on the APL you use.

k, 5 bytes
1+!10

Explanation:
1+ //Projection of +, add 1 to the argument
!10 // "til" 10 - i.e. generate a list of numbers from 0 to n-1

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

You can also do 1_!11, which seems faster (at least in kdb+).. count 0..10 then drop the first element, rather than adding 1 to each item of a 10 item list.

APL with any ⎕IO, 9 bytes.
1-⎕IO-⍳10

APL with ⎕IO=0, 5 bytes.
1+⍳10

Japt, 3 bytes
1oB

This is very simple: o creates a semi-inclusive range between two values, and B is pre-defined to 11. Thus, this creates the range [1..11), or [1,2,3,4,5,6,7,8,9,10], which is automatically sent to STDOUT.
Test it online!

Why not just Aõ? (EDIT: Should have checked the date first!)

Lithp, 64 bytes
((import "lists")(def f #::((each (seq 1 10) #N::((print N))))))

Fairly simple, but unfortunately fairly verbose. I'm counting the import because modules don't automatically load (ie, each and seq are from the lists module, and need to be imported manually.)
To use:
(
    (import "lists")(def f #::((each (seq 1 10) #N::((print N)))))
    (f)
)

Alternate Answer, 68 bytes, recursive and no modules
(def x #::((def y #N::((print N)(if (< N 10) ((y (+ N 1))))))(y 1)))

Defines a recursive function y which calls itself until N is 10.
I've made this a little more readable here:
(
    (def x #::(
        (def y #N::(
            (print N)
            (if (< N 10) (
                (y (+ N 1))
            ))
        ))
        (y 1)
    ))
    (x)
)

Sadly my language is a bit verbose, but Lisp-like language tend to do that. I'm more interested in ensuring the language can handle everything I'd want to throw at it.

DARTMOUTH BASIC,42 BYTES
EH, WHY NOT?
1 FOR I=1 TO 10
2 PRINT I
3 NEXT I
4 END

Do you need the 4 END with DARTMOUTH BASIC? Does the symbolic listing not end when there is nothing left to interpret?

ASMD, 5 bytes
T(i{p

Body must be at least 30 characters; you entered 20.

Kotlin: 30?/31/49 bytes

Variable of function type: 30 bytes
val a={(1..10).map(::println)}

This might be considered cheating.
Invokable via a() like the later function. Functions are first-class citizens in Kotlin, so they can be assigned to variables aswell. The type of ´val a´ is technically () -> List<Unit>, a function that takes nothing and returns a "list of nothing", but we wouldn't be on code golf using a language that doesn't have implicit types, would we?

Function: 31 bytes
fun a(){(1..10).map(::println)}

Executable: 49 bytes
fun main(a:Array<String>){(1..10).map(::println)}

Brainf***, 57 Bytes
++++[>++++<-]>[>++>+++>+++<<<-]+++++++++[>>+.<.<-]>>>+.-.

This is my first attempt at a program in this language. I think it's pretty optomized

Are you sure? I'm afraid this in best case outputs the characters with codes 1..10 (“␁␂␃␄␅␆␇␈␉␊”), not the numbers 1..10.

Yeah, so that's my bad. The Esoteric IDE that I'm using has it print out 1,2,3...10

Okay, I've redone it. Does that look better?

Yepp, except the . immediately after the last loop, which outputs an unnecessary ␀ character.

Ha. Forgot about that. I was using that for troubleshooting. Thanks for the help!

MATLAB, 4 Bytes
1:10

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

The colon operator acts as a range function in Matlab, working from the preceding number to second one, with a default step of 1. (1:3) returns [1,2,3]
As for printing, MatLab Auto prints any line not terminated with a semicolon; Printing a line actually saves space!

Brainfuck, 59 Bytes
+++++[>++++++++++>++<<-]>-<+++++++++[>.+>.<<-]>---------.-.

Cubix, 12 bytes
\;;u>)ONo-?@

Test it online! I will add an explanation within the next few hours.

SmileBASIC, 19 bytes
FOR I=1TO 10?I
NEXT

Nothing to see here

Batch: 36 bytes
for /l %%i in (1,1,10) do (echo %%i)

Breakdown:
for: for operation in batch. Similar to C.

/l: option for the above command

%%i: define %%i, or %i in CMD, just like how you would define i in a for loop in C

in (1,1,10): pretty much "in (start, step, increment)", or in C " for (start, increment, step)".

do: well, run the code after this each time %%i is between 1-10.

(echo %%i): print %%i which is going from 1 to 10

Q/KDB+ 8 Bytes
1+til 10

Explanation:
til 10

Outputs list of numbers 0 to 9
1+

Increments each number in the list by one
Output:1 2 3 4 5 6 7 8 9 10

1 byte shorter using k shorthand 1+(!)10

Python 3: 24 bytes
print(list(range(1,11)))

Simply print a list of the range.
Outputs:

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

Microscript, 7 bytes
10c1p]h

Microscript II, 10 bytes
0s{1+Ps}s10*

Pip, 3+1 = 4 bytes
\,t

Runs with the -n flag to separate the output with newlines.
Try it online!
Explanation:
\,         Inclusive range of 1 to
  t        10

@DLosc Thanks, that shortens it considerably. But how does it owrk though? Does \, create a range-object with the values 1 to t==10 inclusive, which it auto-prints (as that range-object is the last variable touched by Pip?)

Yep! Exactly. (It's possible this is "using features newer than the question," because I can't recall when I changed the behavior so non-infinite ranges would output like lists, but that's allowable anyway. \, is not an issue--it was added last January.)

Perl, 19 bytes
@x=1..10;print"@x";

The ".." operator can print an ascending list of numbers or letters.
So @x = A..Z; print "@x"; will print capital letters A through Z.
I saved quite a few bytes by removing all spaces.

AWK, 26 bytes
BEGIN{for(;i<=9;)print++i}

Try it online!
I don't see an AWK answer, so here we go. I chose to use <=9 rather than <10 just to add a little variety since they have the same byte-count. :)

Initially I had i++ in the for-loop, but that required a space in the print command.

A while loop would be the same length here.

True, @CalculatorFeline, but since a while loop is never fewer bytes than a for loop, I've gotten out of the habit of using them.

I think you can change BEGIN to END to save 2 bytes.

If you use END, then AWK will expect to receive input. The try online would work, but if you typed it in, it would wait until input was supplied. You could just do a  in bash, but it still expects something as input when you have an END statement.

PHP (with goto) - 46 38 34 bytes
More byte-saving suggestion from Shaggy:
<?php Z:echo@++$i;if($i<10)goto Z;

And people say that goto is the work of the Devil. Or something.
Try it online
PHP (goto-less) - 30 29 bytes
<?php while(@$i<11)echo@$i++;

PHP - 11 bytes
12345678910

Well, someone had to?

Save 4 bytes by replacing ten with a single character variable name and another 4 by removing the php .

Thanks, then I won't have goto ten but anyways

Why is the 11-byte version non-competing? This is a [tag:kolmogorov-complexity] challenge; hardcoded answers are allowed.

Okay I will amend if you say that I must.

Charcoal, 5 bytes
Ｉ…·¹χ

Try it online!
Explanation:
Ｉ        Implicitly print the elements (casted as string) of
  …·      the inclusive range
    ¹χ    from 1 to 10 (default value of the χ variable)

4 bytes now

Carrot, 20 bytes
1 2 3 4 5 6 7 8 9 10

Or if we don't need a separator for 11 bytes:
12345678910

Anything before a ^ in Carrot is placed onto the stack and then that is implicitly output at the end of the program.
With the current version of Carrot this seems to be the shortest way of doing it although I would like to post a none hard coded version if I find one.

cQuents, 6 4 bytes
#t&$

Try it online!
Explanation
#t       Set default input (n) to 10
  &      Mode: Sequence 2 (print first n items in sequence, 1-indexed)
   $     Each item in the sequence is the current index

T-SQL, 27 bytes
Boring answer.
PRINT'1,2,3,4,5,6,7,8,9,10'

Less boring with a WHILE, 51 bytes
DECLARE @ INT=1WHILE @<11BEGIN PRINT @ SET @+=1 END

Cubically, 16 bytes
(*1+1/1%@LUL'B)8

Try it online!
(*1+1/1%@LUL'B)8
(                 do..while loop
 *1+1/1            add 1 to notepad
       %           print notepad as integer
        @          output notepad as ASCII (delimiters)
         LUL'B     algorithm with period 10
              )8  loop while cube unsolved

Output (? denotes an unprintable):
1?2?3?4?5?6?7?8?9   10

Pyth, 4 2 bytes
Well, I guess I think more about legitimate functionality/usability, but this is Code Golf, where usability comes after functionality.
-2 by not formatting my output.
ST

Explanation:
S        1-indexed range from 1 - ...
 T       Ten

Try It Online!
Pyth, 4 bytes
VSTN

Explanation:
V        For...
 ST      in the 1-indexed range from 1 - 10 (T)
   N     Print the current item

Try it online!
Or alternatively...
VThN

Explanation:
V        For...
 T       In range from 0 - 9
  hN     Print (the current item + 1)

Try it online!
Pretty simple.

Your output format can be whatever your language supports. This includes arbitrary separators (commas, semicolons, newlines, combinations of those, etc., but no digits), prefixes and postfixes (like [...]).

This means that ST is valid

@Tornado547 wow, that is odd. many thanks

Julia 0.6, 11 bytes
show.(1:10)

Try it online!

Forte, 64 bytes
12PRINT42-41:LET42=42+1:LET11=11+3
13LET99=11
99LET12=12+3
40END

Try it online!
How?
In Forte, you do things by redefining numbers. For example, LET 4=5 is a statement that defines 4 to be 5. From now on, anytime 4 occurs in the program, it is replaced by 5--even as the result of expressions like 2+2. There are no looping constructs in the language; control flow is accomplished by redefining line numbers.
With that introduction, let's look at what this program does.
The first line executed is line 12. This prints 42-41, which (currently) results in 1. Next, it redefines 42 to be 42+1--that is, 43. From now on, anytime 42 occurs in the program, we'll actually use the value 43. Finally, it redefines 11 to be 11+3--that is, 14. This is setup for the loop we're about to enter.

Redefinitions: 11->14; 42->43

Line 13 is executed next. It redefines 99 to be 11--except 11 has previously been redefined, so 99 actually becomes 14.

Redefinitions: 11,99->14; 42->43

Now, the previous instruction has an effect on the control flow, because 99 happens to be a line number. Line 99 is now considered to be line 14, and thus we execute it next (rather than line 40, which would otherwise have come next). This line redefines 12 to be 12+3--that is, 15.

Redefinitions: 11,99->14; 12->15; 42->43

And now the next instruction is the newly christened line 15, which prints 42-41 again... except that 42 is now 43, so it actually outputs 2. It then redefines 42 43 as 44 and 11 14 as 17.

Redefinitions: 11,14,99->17; 12->15; 42,43->44

The next instruction is line 17 (the original line 99), which redefines 15 to be 18. And so lines 12/15/18 and 99/11/14/17 keep alternating back and forth, incrementing each other and printing ever-increasing values of 42-41, until we reach line 39. This prints 10 (42 now having reached a value of 51), redefines 42 and 11 again (but that won't matter), and then we move on to the next statement, line 40--which ends the program.
Simple, right?

17, 48 bytes
17 was made after the challenge was released, so it is not competing, though it still scored worse than most other answers because it isn't a golfing language, or very usable at all.
Outputs 1 to 10 seperates by \x11 (ascii value 17)
0{#
1 +
:
10 @
9 >
0 @
# $$
$}777{0 10 @
0 0 @}

Block 777(first block run): Initialises value 17 to 0. Runs block 0
Block 0: Loads value 17(relies on returning of 17 from stack when empty stack), adds 1, duplicates, stores at 17, if value > 9 pushes 1, else 0, stores value at 0, loads from 17, prints number, print ascii charater 17(relies on returning of 17 from stack when empty stack again)

Pyt, 3 bytes
1ᴇř

1     push 1
 ᴇ    10^1
  ř   range from 1 to 10
      Implicit output

Try it online!

Canvas, 4 2 bytes
ＡＲ

Try it here!

Perl 6, 11 bytes
Two solutions with the same count:
print ^10+1

and
print 1..10

Output: 1 2 3 4 5 6 7 8 9 10
Try both of them on Try It Online!

Sd, 50 Bytes
++++++++++@**********.-/.-/.-/.-/.-/.-/.-/.-/.-/.!

How it works:
++++++++++                                          | Set variable 1 to 10
          @                                         | Mark read location
           **********                               | Set variable 2 to 10
                     .                              | Replace the instruction in position given by variable 2 with the ascii character given by variable 1
                      -/.                           | Subtract one from each variable and repeat
                         -/.-/.-/.-/.-/.-/.-/.-/.   | Repeat some more
                                                 !  | Print all values before the @ (as ascii)

Stax, 2 bytes
Am

Run online
Added for completeness.
A       Push 10
 m      Map over range, implicit output

Jotlin, 15 12 bytes
p((0..9)+10)

Gets the numbers 0..10, makes a list out of them, and then prints the result

QUARK, Non competing 7 bytes
5.625 bytes encoded.
1 10⋯

This is incredibly simple. Just pushes 1 and 10 to the stack, and creates a inclusive range out of them. The interpreter prints out the contents of the stack when the program ends, so no print command is needed. (Plus the print command doesn't work with arrays yet, and prints out a garbled mess, so :P)

rig, 3 bytes
rig is a work-in-progress esoteric stack-based language. I'm just having fun with looking for challenges it can already solve, with its few commands.
τr+

is a valid code that prints "1,2,3,4,5,6,7,8,9,10"
Try it here
Why?
τ    - push 10 to the stack              [10]
 r   - push range(10) to the stack       [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
  +  - increment every element           [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     - implicit print

Stack Cats, 28 + 4 (-nm) = 32 bytes
-(:!_:!_:-_-_]>{<:_-!:]}]<)-

Try it online!
Stack Cats is a reversible esoteric language by Martin Ender. All of its commands can be reversed by applying the command's mirror image, and the whole code itself must be the mirror image of itself. Since half of the code is always redundant, it has -l and -m flags which allow to omit half of the program. -m appends the mirror image to the right (except the center character), so the full program is -(:!_:!_:-_-_]>{<:_-!:]}]<)-(>[{[:!-_:>}<[_-_-:_!:_!:)-.
Stack Cats operates on an infinite tape of stacks, all of which are initially empty with infinite amount of implicit zeroes at the bottom. Here is a summary for the relevant commands:

- Negate the top.
! Apply bitwise NOT to the top.
: Exchange top two elements of the current stack.
_ Pop a, Pop b, Push b, Push b-a.
>, < Move the cursor right or left.
], [ Move the cursor right or left, along with the top. (Also called "Push")
(, ) Enter or exit a loop if the top is strictly positive.
{ Enter a loop and remember the top.
} Exit a loop if the current top is equal to the remembered top.

Also, due to the limitations of the language, the input/output occurs only at the start/end of the program. At the start of the program, each input is pushed to the initial stack, which has a -1 at the bottom. At the end of the program, all values on the stack are printed from top to bottom, with optional -1 at the bottom ignored. So this program starts with a single -1 on the stack, and ends with 1..10 on the current stack.
How the code works:
Code    Stack                  Description
        [-1]
-(      [1]                    Negate the top; Enter the loop
:!_     [1 0]->[1 -1]->[1 2]   Swap top two (with implicit zero); Bit-NOT; Subtract
:!_     [2 1]->[2 -2]->[2 4]   Same
:-_     [4 2]->[4 -2]->[4 6]   Swap; Unary minus; Subtract
-_      [4 -6]->[4 10]         Generate 10
]>      [4] [10] [*]           Push 10 to a new stack; Move right again
{                              Remember 0
<:      [4] [n 0*] [...]       Swap with implicit zero
_-!     [4] [n n-1*] [...]     Generate n-1
:]      [4] [n-1] [... n*]     Push n to the right
}                              Loop while n is not zero
]<                             Remove last zero
)                              Top is 1; Exit the loop
-(...)-                        Skip the rest

There is a standard construct <(...)*(...)> which allows to ignore half of the program, in order to program more effectively by human. I used a similar one -(...)-(...)- which utilizes the initial -1, but it only works with no-input programs and the final top should be strictly positive.
Ignoring half of the program is quite a waste of space, so there is an open bounty for more efficient golfing with both halves. I'm aiming for this in the long run, though it's not yet clear how to even start tackling the problem.

KoopaScript, 78 (28, 20) bytes
def i a if \%va is \%v set a 0;setath a \%va + 1;if \%va smaller 11 print \%va

This prints the numbers 1 to 10, as well as a lot of information about the currently running code (because reasons). KS doesn't actually have a way to break loops yet, so this keeps running until the interpreter is reloaded. It stops printing at 10, though.
def i a               - Define a function with the name i and call it 1000/NaN (i.e. many) times a second
if \%va is \%v        - if the variable with the name a is undefined,
set a 0;              - set it to 0
setath a \%va + 1;    - set the variable a to <the variable with the name a> + 1
if \%va smaller 11    - if the variable with the name a is smaller than 11,
print \%va            - trace the variable with the name a

To avoid printing debug info, either load this in an init script, or use this slightly longer (90) version that disables logging:
def i a set verbose;if \%va is \%v set a 0;setath a \%va + 1;if \%va smaller 11 print \%va

set verbose;          - set the variable called 'verbose' (which handles whether to trace debugging stuff) to ""

Alternatively,
print "1 2 3 4 5 6 7 8 9 10"

This is only 28 bytes and technically does what the specification entails. Other commands, e.g. if, display all the numbers, but, as it's caused by an error in the program, it doesn't display if logging is disabled.
Technically,
1 2 3 4 5 6 7 8 9 10

prints all the numbers with commas between them, in the debug log. That brings it down to 20. I guess it's up to the reader (stacker? golfer?) to decide which one is the most correct

Deadfish~, 4 bytes
{io}

Try it online!
Increment, then output; repeat ten times.

(K+R)eg, 6 bytes (SBCS)
6 bytes:
\
ï_(.

11 bytes:
9(9|:"1-)1$

Try it online!
One byte longer
How it works
9(9|:"1-) # A countup program from 1 to 9 and then (astonishingly) adds a 0; I have no idea how it works.
1         # Push 1
$         # Swap top 2 items
# The stack is implicitly outputted.

0ėɧ 3 bytes in the new interpreter

ėø once I add the ø operator

Keg, 5 bytes
I am too lazy to change my answers to conform the new code page, unless I get notified.
ėÏ_(.

Push 10(saving a byte), take iota [10..0], remove last, and then print.

TacO, 7 bytes
@%10
 i

try it online!
The number 10 is the first branch of the looping construct %, so TacO runs the second branch, which just contains i, 10 times, giving i numbers 1-10.

Seed, 4232 4039 3981 bytes
To be golfed.
11 806065440241409087125357198607542800075970572928765093042958164984128856153119364694304946533565974155065813564463607464907294493213625991570210498180131922642836049048379926678214090306958078942950505666942158861663318082805922649360548872276728753092705551896201785489318797454097467866454815778688721780170362909784978852186756623253868868917034035335528463229661772327867673360158173714723733025733656646487909489808220640703644162017799947346882823939914644265408484708544566367174322747059393061445510836708923637982737011363312927325448282786060215442674975310709523697911998742881715764878830975686475127091070151990734113230052589483007904386955837951416230150553553131824081272209795780490205576443141598594094128682959852257277648831764416301409205933849585487706444517684177487650836580944108733813423567329150282262574305747736976499413900964122878760201959007114022481011295839141271138446203186069264532462250500186116493184286012088625239590991537830133224608224949348931933311034455280978164515936125672561757104517575527099692465553902153481143524868360127998596923638301974413167583429193105287970847431486813381197765539764522094782334194830005111603128673518265195317929281022739571069159575305773074583173243911197334517405412628068284686691469982559791730541223895403558031955848768117060646768348463561209935808045637507281128179915889035768211511504144114447348017724691523076211025635445333081644368060430405389019848215116047520242946447978917490619742817523907421559319563570816232286092378925478777387843124296450405990835394943021252863488969545687903232603331252281246680860082655523490245738107512918342578050153655018310720283275985429190062871812385817909146120892975424714212971890662091259299688100739835789852338707333214399083184648552682989269071097042033924364887158088125417342061047907455595001558776113845342454604060641417114322284932278126981432767955018317987960683429833483125151020913178712494155310545261553444170641615117711305756617133820567957209040625095889033833683868477968222981257864647555382502179925116320599028456728151421211950504164587366555426478479957000176097833838329163859553682184378396176530388849222864560228925976975341162944244301834305126128097819354250219559409487388887032429560483598135806164050794728591878728116747953265919795701481292222092677282626562421120330436952746759320383166496345689472683465785160396471114988424810146619802843389460581036625456336614635949441077117888570209114560201469774858952308539634363125726651042307946127813908314293240378846347559662225224004298822713302904050471977675138246925540751643515879128105969891674920959645532198204680833150120401421252646736795292132103275342152265451058336500878555688383134027160586652276624279294501247326175308886148638933724425782375226226354458022684652099014849380343822015940473137950787091045988775407006084669595433268270085699081145780497235745383972369977375564713816849012360495596752065665250235877504147680897910657602532177993907221958136528121236676455264099257048759319470710174615005668917675853889646496531814039709503285164186416096735666867062585670181891889551756178657495723233678891549411496581200696462439988553007997103954989290028776888309286564702133992674291744804531900851060090385178725409757099606879757766288322010567612896350258272282241111517435795569303408578713936760574865986977532034796036053889911992836923158428809242575557886427002935479153509101800373188079516076598125218940752155364580400861924119667725548877677649837117601878482958020472764206345843076482381692875591020886968748894499648171413242376922343979630964910668516043571246988639289969853916731069660002514237788846617524295024699798200028558752532671916185460167291108476912591550362203490594401624213451585637461718363114331483866061411154610681167668195013207060532734483192219734129165226320299742868143084807270641847983148272764305800992489421803505337228286598600236556437401089147741524552516814465259338644189950504662

Try it online!

Javascript 45 Bytes
alert("10charstrn".split("").map((e,i)=>i+1))

This is currently quite poor, but if there happens to be a JS constant which is an array of length 10, this could improve a lot.

Array(10).fill() is the first thing that came to mind for an array of length 10. (Array(10).map... does not work, at least on my browser.)

I mean, just alert([1,2,3,4,5,6,7,8,9,10]) is way shorter

I'm pretty sure alert([1,2,3,4,5,6,7,8,9,10]) is already an answer somewhere within these seven pages of answers... might as well golf the method that's already here methinks

(top+'').split('',10) <-- saves 1 byte compared to "10charstrn".split(""). top refers to window.top, and the string representation is "[object Window]" (15 chars). The .split() method takes a separator and an optional limit. Since all you need is 10 chars, split into an array, this should do just fine.

Perl 5, 13 bytes
say for 1..10

Example execution
perl -E 'say for 1..10'

Poetic, 163 bytes
this is asking a lot
o,i admit i was a victim
i was tired of this situation
o,i had a break
i couldnt be sicker of it
thats a very different outcome than i thought

Try it online!
Outputs the numbers from 1 to 10, separated by ASCII 0 (NUL) characters.
For being such a simple type of program, this was an interesting challenge to golf.

Intcode, 49 bytes
4,15,1001,15,1,15,8,15,16,14,1006,14,0,99,-1,1,11

Why am I still doing this? Because it's fun. That's why.

Wren, 28 bytes
System.write((1..10).toList)

Try it online!
Explanation
System.write(              )  // Output
             (1..10)          // Numbers from 1 to 10
                    .toList   // Converted to a list

Intcode, 44 42 bytes
-2 bytes thanks to rootbeersoup
204,8,9,8,1205,8,0,99,1,2,3,4,5,6,7,8,9,10

Try it online!
Isn't it unfortunate that a just-hardcode solution outgolfs the other intcode answer by six bytes?

Saves 2 chars: 204,8,9,8,1205,8,0,99,1,2,3,4,5,6,7,8,9,10

W z, 4 bytes
10aM

Just does a range from (implicit) 1 to 10.

Keg, 8 bytes
Still wasn't used to the flags...

Ï_(. ,

Try it online!

Spice, 55 bytes
My solution is posted as to the language spec, which currently fails because of an interpreter bug. To run against the interpreter the score falls to 63 bytes due to 2 NUL statements being required.
;a@ADD a 1 a;SWI a 10 0;LOD std::sort.spice ^a a;OUT a;

Or with the additional NULs.
;a@NUL;NUL;ADD a 1 a;SWI a 10 2;LOD std::sort.spice ^a a;OUT a;

Un-golfed Explanation
;a@          - declare variable 'a'
ADD a 1 a;   - ADD a[0] to 1 and insert at a[0], empty "a" implicitly 0
SWI a 10 0;  - If a[0] < 10, jump to line 0 (ADD...)
LOD std::sort.spice ^a a; - Use std lib to sort a 1->10
OUT a;       - Output a

GolfScript, 6 bytes
It hasn't been done? Then great. Generates 0 to 10 and removes 0, then it evaluates.
11,1>`

Try it online!

Rogex, 27 bytes
90B300d00901e00100701a20f00

Try it online!
Explained
90B 300 d00 # Set the loop value to 11
901         # Set the buffer to 1
e00         # While the buffer isn't equal to 11
    100 701 # Print the buffer then increment it
    a20     # Print a space
f00         # End loop

Rogex answer number 2! Also, my 101st answer! (´• ヮ •`)

MAWP, 13 bytes
25W[1A~!:1M~]

Try it!

The integer complexity thing in 1+ is frustrating...

yup lol, I should try golfing 1+ sometime

1+, 25 22 bytes
1:1(|1+":1+":1+":)()()

...
EDIT: The boring solution is shorter.

Rockstar, 32 bytes
X's0
while 10-X
let X be+1
say X

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

BitCycle -u, 40 bytes
v0 ~
v1~/
AB~
v000000<
AB\ 000^
v =@
!1<

Try it online!
Explanation pending. I need to sleep first.
(I also found a 36-byte program that outputs 0 through 9, but I haven't found a good way to turn it into 1 through 10.)

Ly, 13 4 bytes
`9`R

I found a better way. :)
`     incrementing the empty top of stack pushes a 1
 9    push 9 onto the stack
  `   increment the top of stack to get "10"
   R  generate the inclusive range of int between the top 2 stack entries

The stack entries are printed as numbers by default when the code exits.
Try it online!

Headascii, 50 bytes
++++[]]]][]]]+O^+O+O+O+O+O+O+O+ODONE.{UPN)!@}:R-P!

Try it here! Code will need to be copied and executed like this:
erun("++++[]]]][]]]+O^+O+O+O+O+O+O+O+ODONE.{UPN)!@}:R-P!")

Outputs each number separated by newline. Nontrivial challenges scare me :')
++++[]]]][]]]+O^+O+O+O+O+O+O+O+ODONE.{UPN)!@}:R-P!  full program
                                    .               code block delimiter

++++[]]]][]]]+O^+O+O+O+O+O+O+O+ODONE  block 0
              O  O O O O O O O O O    send
++++[]]]][]]]+                        49 (ascii 1)
                +                     50 (ascii 2)
                  +                   51 (ascii 3)
                    +                 52 (ascii 4)
                      +               53 (ascii 5)
                        +             54 (ascii 6)
                          +           55 (ascii 7)
                            +         56 (ascii 8)
                              +       57 (ascii 9)
               ^                D     49 (ascii 1)
                                  NE  to code block 1

{UPN)!@}:R-P!  block 1
{      }       Loop
   N)   :      Until last value
 UP              Put value on string register
     !@          Print and clear string register
         R     Recall last value (49)
          -    Minus 1 (48, ascii 0)
           P!  Concatenate to string register and print

Sending inputs to code block to loop print saves 5 bytes over printing each individually, but it might be possible to save more bytes by doing some sort of for-loop type structure from the beginning. Storing 9 as well as 48 seems expensive, though.

Julia 1.7, 14 bytes
print((1:10)')

Try it online!
1:10 returns a Range. Note that in Julia 0.2 we can just use print(1:10). This does not work in later versions (I've tested this starting from Julia 0.4).
We could use print(collect(1:10)). But this is costly. But we can use a trick by using the ' transpose operator.
There is also an answer for Julia 0.6 which uses show.(1:10) as this prints 1-10, it prints additional stuff in newer Versions of Julia due to the nature of broadcasting, namely,
12345678910
10-element Vector{Nothing}:
 nothing
 nothing
 nothing
 nothing
 nothing
 nothing
 nothing
 nothing
 nothing
 nothing

use show instead of print for -1 byte

show.(1:10) is fine in any version as the additional output is produced only in the REPL. You can mute it by appending a ;

@amelies cool! I didn't know that.

Ruby, 20 bytes
(1..10).each{|i|p i}
Cannot be any simpler than this.
Attempt This Online!

1.upto(10){p _1} is 16

@Razetime Damn you are right.

@Razetime For some reason when running on ATO it refuse to run and running on TIO returns error so I am gonna leave this for a while.

You should report this problem to pxeger. If you wanna verify it, try running it on irb in your terminal.

I have reported this to him, and run the code on irb also seems to run fine.

8 bytes

Flobnar, 22 bytes
+<> v:
,-|\@1
.9>> +
:

Try it online!
\@1
> +   Set TOS to 1 on init (and increment TOS on every iteration)
  :

:
+<    Print TOS as number, print 0 (return value of `.`) as char,
,-|   and check if TOS - 9 is zero
.9
:

> v
| @1  Return to start with updated TOS if nonzero,
>  +  evaluate to TOS+1 (10) otherwise (which is printed at the end)
   :

Fig, \$3\log_{256}(96)\approx\$ 2.469 bytes
a10

Try it online!
I dare you to golf this further.

Go, 52 bytes
import."fmt"
func f(){for i:=1;i<11;i++{Println(i)}}

Attempt This Online!
Go, 39 bytes, prints to STDERR
func f(){for i:=1;i<11;i++{println(i)}}

Attempt This Online!

shell commands, 7 bytes
seq 10

or also
jot 10

Thanks.

Which shell? with coreutils?

Hello @qwr Those are external tools. GNU Core Utils provides seq since 1.13 shell utilities release ; but it's available under other Unixes too. In fact, it appeared in Version 8 AT&T UNIX first, then NetBSD 3.0, and was ported to FreeBSD 9.0. It's also part of the native Win32 ports.  (to be followed)

(continuation) The alternative jot first appeared in 4.2BSD and is available under most GNU/Linux too as specific package: athena-jot for Debian based, outils-jot for Alpine.. It's fancier than seq, and all implementations share the same options. (end)

Uiua SBCS, 5 bytes
+1⇡10

Try it!

YASEPL, 10 bytes
=a`1+<}4,9

Welcome to Code Golf SE, nice language

@noodle-man thank you noodle man

jq, 12 characters
(11 characters code + 1 character command line option.)
range(1;11)

Sample run:
bash-4.3$ jq -n 'range(1;11)'
1
2
3
4
5
6
7
8
9
10

On-line test

JavaScript (using external library) (39 bytes)
x=>console.log(_.Range(1,10).Write(""))

Link to lib:https://github.com/mvegh1/Enumerable/
Explanation of code: _.Range creates the array [1,..10], Write joins the array into a string, console.log puts to StdOut

I was thinking about using something like Underscore's range, but figured something pure would be a bit more impressive. Nice solution!

Thanks! Yeah yours is way shorter than mine hahaha, I need to learn the ... syntax!

MDN has an article on the Spread Operator :) -- I started with [...Array(10)].map((v,i)=>++i), but that was 30 bytes and I was hoping to do better than the first JavaScript answer on here (24 bytes)! Then I realized that a String is, more or less, just an array of characters. So I tried the spread operator, and viola!

Ahhhh ok wow I see what its doing. Not bad!!

JavaScript (Node.JS 5 / Harmony / ES2015), 19 bytes
[...`123456789`,10]

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

Try it here or run node -p -e "[...'123456789',10]"
(For older versions of Node.js, like LTS 4.4.7, use node --harmony)

Previous attempts were: [...Array(10)].map((v,i)=>++i) and [...Array(11).keys()].slice(1), but both ended up with 30 bytes, which was less than the other JavaScript submissions here.

Your code does not print the integers; but as -p clearly adds functionality to it, there should be some penalty for it imo. 2) When I log that to my console (without node), I get an array with nine strings and one integer 3) This is pretty close to a hard coded result.

There were both an [...Array(10)].map((_,i)=>i+1) and an [...Array(11).keys()].slice(1) elsewhere, just wrapped with alert making them 37 bytes

@Titus (1) This is Node.JS, not browser-based JavaScript. They are two different things. However, I can kind of see your point with -p. (2) "This includes arbitrary separators (commas, semicolons, newlines, combinations of those, etc., but no digits), prefixes and postfixes (like [...])." (3) Arguable.

@PaoloBonzini You're late to the party. Both of those were posted by Titus four hours ago. Both of which I left in the comments here and on another answer roughly 24 hours ago :) Granted, I didn't put them in my solution, but that's beside the point. -- As for using an alert instead, I defer to (1) in my response to Titus. I primarily develop in Node.JS and use the Node.JS REPL, not browser-based JavaScript. These are two different platforms; similar implementations of a similar spec, but arguably not the same exact thing. I respect the position, though.

@Swivel: (1) accepted, my mistake. Keep telling people that JavaScript is not Java, now I fall for the same trap. (2) accepted. (3) now that I think of it, yes it is arguable. Ok, I learned some Node.JS from it.

@Titus No problem at all! Learning is what it's all about! :) I've learned a ton looking through the answers on code-golf and others; I'm sure tons of others have too.

Excel VBA, 20 Bytes
Anonymous VBE immediates window function that takes no input and outputs to the VBE Immediates window
For i=1To 10:?i:Next

LibreLogo, 20 bytes
Code:
print set range 1 11

Output:

Triangular, 15 bytes
S](l.U@..i/AS%<

Formats into this triangle:
    S
   ] (
  l . U
 @ . . i
/ A S % <

The first command, S, stashes the top of stack (0) in memory. (This is only so that the U will work the first time.)
( opens a loop.
U pulls memory onto stack.
i increments the stack value.
< directs the IP left, hitting %, which prints the top of stack as an integer.
S stashes the top of stack in memory.
A pushes 10 to the stack.
/ directs the IP up-right, hitting @, which prints the top of stack (10) as ASCII (\n).
l checks if the second-to-last stack value (the counter value) is less than 10.
If so, jump back to (. Otherwise, exit the program.

14

anyfix, 3 bytes
⁴RK

Note that TIO says that this is 5 bytes but that is because of the unicode character ⁴; in the codepage of anyfix (which is the same as the Jelly codepage), this solution encodes to 3 bytes.
Explanation
⁴   10
 R  Range [1..10]
  K Join on spaces

Alternatively, ⁴RY separates by newlines. R⁴K and R⁴Y also work because one of the key features of anyfix is that it works with prefix, infix, and postfix (though K and Y will work regardless of what's on the stack because if the top of the stack is not a list or does not exist, then it will use the entire stack as a list). Alternatively, R⁴ or ⁴R and the @l interpreter flag will make it output [[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]] because @l makes it output the stack as its string representation in Python.
Try it online!

8th, 18 bytes
( . cr ) 1 10 loop

MY (noncompeting), 3 bytes
Here's the hex:
0A 49 27

Finally, a reasonable solution. Explanation:
0A - Push 10 to the stack
49 - Pop n; Push [1 ... n]
27 - Pop n; Output n

Swift 3, 20 bytes
print(Array(1...10))

Welcome on Programming Puzzle & Code Golf. About the downvote on your answer: it was automatically applied by the system when @Toto edited your answer from the "First Post" review queue; but no one actually downvoted it. Happy golfing!

TLDCode, 12 10 Bytes
='1'p9{c+}

Clears the stack of the default input, pushes 1 to the stack, parses it from a string to a number, reapeats c+ 9 times, which copies the top of the stack and pushes to the stop of the stack, then incremetnts it. Implicitly prints the stack with _ as the seperator.
Output
1_2_3_4_5_6_7_8_9_10

Previous attempt (12 bytes)
'1'pe9{n+e}=

Pushes 1 to the stack, parses it from a string to a number and prints, then repeats n+e 9 times, which prints a new line, increments the top of the stack and then prints the top. Then it clears the stack to avoid the implicit printing of the default input.
Output
1
2
3
4
5
6
7
8
9
10

Firebird, 113 bytes
The compacted select, used to calculate the score is below:
WITH RECURSIVE T AS (SELECT 1 AS I FROM RDB$DATABASE UNION ALL SELECT 1+I FROM T WHERE I < 10 ) SELECT * FROM T

The formated select:
WITH RECURSIVE T AS (
  SELECT 1 AS I
  FROM RDB$DATABASE
  UNION ALL
  SELECT 1+I
  FROM T
  WHERE I < 10
)
SELECT *
FROM T

Short explanation: I start with a select on a system table from firebird, witch always has only one record. Then, using recursion on that projection, I add the column "I" until it reaches 10.

Welcome to PPCG! Seems like a decent first post, but I think that you could improve it by giving a short explanation for how it works.

Thanks. Yes, I should have add a short explanation on my answer. Already updated it.

Can you remove some of the spaces/newlines?

@CalculatorFeline Yes I Can! Will do that now, thanks!

Python 2.7, 17 bytes
print range(1,11)

Why 11? The range() function is non-inclusive for the end argument.
repl.it

Duplicate of TuukkaX's Python2 answer posted 11 months earlier. (With sufficient privileges you could see that there are already 3 completely or partially identical deleted answers too.)

@manatwork Oops. Sorry.

Python 3, 24 bytes
print(list(range(1,11)))

Try it online!

tcl, 23
time {puts [incr i]} 10

demo

><>, 10 bytes
llnao:9=?;

Try it online!
Explanation:
This program pushes the length of the stack instead of trying to increment the top of the stack, because l is shorter than 1+, and you can do it to an empty stack.
l             Push the length of the stack. The first time through pushes 0.
 ln           Print the length of the stack. The first time through prints 1.
   ao         Print a linefeed. (ASCII value 10)
     :9=      If the top of the stack is 9 (i.e. we just printed 10), push 1.
              Otherwise, push 0.
        ?;    If the top of the stack is non-0, end the program.

              Wrap to the start and Repeat. At the end of the loop, we end up
              with one more value on the stack than we started with.

Whoops, I didn't see the other ><> answer that also uses the length of the stack as an incrementer. I'm going to leave this up, but you should really go upvote them if you're going to upvote me. It's even the same byte count.

Python 2, 19 Bytes
print range(11)[1:]

Try it online!

AnyDice, 10 bytes
output d10

Try it here.
This program creates and outputs a single 10 sided die. This lists out the numbers on the die (1-10) next to a bar graph of the probabilities in the standard output form.

Eukleides, 26 bytes
for i=1 to 10
print i
end

Beats hardcoding by 2 bytes.

><>, 17 Bytes
1>:nao1\
;\?(b:+/

Pretty basic:
1                       | Push 1 to the stack
 >                      | Make sure pointer is going the right direction
  :n                    | Duplicate the number and print it
    ao                  | Print a new line
      1\                | Increment, redirect pointer
      +/                |-┘
   (b:                  | Check that the result is less than 11
;\?                     | If it is, continue looping, else end.

Implicit, 10 bytes
(;.@%<10)&

Try it online!
(            do..while loop
 ;            pop (nothing initially, n<10 after that)
  .           increment (0 initially, n after that)
   @          output ASCII value of n for delimiter
    %         output n as integer
     <10      push n<10
        )    loop while top of stack truthy (n<10)
         &   exit (no implicit output)

Output (? denotes an unprintable):
?1?2?3?4?5?6?7?8    9
10

Bitwise, 208 191 175 bytes
-17 bytes using the registers 3 and 4 instead of function frame registers
-16 bytes using position-based jumps instead of LABELs
.A:
AND $1 $2 3
XOR $1 $2 $1
SL 3 &1 $2
JMP &-4 $2
RET $1
.G:
NOT $1 3
A $2 3 4
A 4 &1 4
SR 4 &31 4
AND 4 &1 4
RET 4
.L:
G $2 $1 3
RET 3
A 1 &1 1
OUTI 1 &1
L 1 &10 2
JMP &-4 2

Try it online!
Explanation:
.A:          # subroutine: arg3 = arg1 + arg2
.G:          # subroutine: arg3 = arg1 > arg2
.L:          # subroutine: arg3 = arg1 < arg2
A 1 &1 1     # add l1 (literal 1) to r1 (register 1)
OUTI 1 &1 -1 # output r1 as integer
L 1 &10 2    # set r2 to r1 < 10
JMP &-4 2    # jump 3 lines back in the code if r2 is nonzero

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

FALSE, 18 17 bytes
0[1+$11-][$."
"]#

Explanation:
0 {push 0}
{conditional function}
[
 1+ {add 1}
 $11- {check if 11}
]
{loop function}
[
 $. {print number}
 "
" {print line break}
]
# {while loop (run second function while first returns true)}

uBASIC, 20 bytes
Anonymous function that takes no input and outputs to the console
0Forx=1To10:?x:NextX

Try it online!

Python3 - 19 Characters
print(*range(1,11))

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

Rust, 42 bytes
fn main(){for i in 1..11{print!("{},",i)}}

jamal, 17 characters
{@for i/1..10/i }

Sample run:
bash-4.4$ jamal.pl number.jam
1 2 3 4 5 6 7 8 9 10

Javascript (potentially non-competing)
As a function (6 bytes):
_=>110

Full program (10 bytes):
alert`110`

This prints all number from 1 to 10 inclusive in binary...
If you closely read the question, there is never any mention about mandatory separators (thus allowing 123456...) nor the output's base...

Afaik, it alerts "110" literally...

@CreaZyp154 1 10 is 1 to 10 in binary

I'm confused ngl...

Rattle, 6 bytes
[+p]10

Try it Online!
Loop 10 times while incrementing and printing each time

Pascal, 55 B
This complete program requires a processor compliant with (at least) ISO standard 7185 “Standard Pascal”.
All numerical values supplied to the built‑in write/writeLn routines have an implementation‑defined minimum printing width.
Considering an implementation defines this width to be 8, the program
program p(output);begin write(1,2,3,4,5,6,7,8,9,10)end.

prints
       1       2       3       4       5       6       7       8       9      10

If you are a user of the FreePascal Compiler, you need to insert a {$mode ISO} compiler directive comment or supply the ‑MISO parameter to the fpc compiler command.
Otherwise the built‑in minimum width is 1, which just concatenates all numbers without any intervening space.

Swift, 18 bytes
print((1...10)+[])

Self-explanatory. This literally just creates a ClosedRange<Int> from 1 to 10, and then converts it to an [Int] by concatenating an empty array literal. (If we don't do this bit, it'll just output it as 1...10 instead of [1, 2, 3, 4, 5, 6, 7, 8, 9, 10].

authors: Xi'an ні війні

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/