text:
1, 2, Fizz, 4, Buzz
Introduction
In our recent effort to collect catalogues of shortest solutions for standard programming exercises, here is PPCG's first ever vanilla FizzBuzz challenge. If you wish to see other catalogue challenges, there is "Hello World!" and "Is this number a prime?".
Challenge
Write a program that prints the decimal numbers from 1 to 100 inclusive. But for multiples of three print “Fizz” instead of the number and for the multiples of five print “Buzz”. For numbers which are multiples of both three and five print “FizzBuzz”.
Output
The output will be a list of numbers (and Fizzes, Buzzes and FizzBuzzes) separated by a newline (either \n or \r\n). A trailing newline is acceptable, but a leading newline is not.  Apart from your choice of newline, the output should look exactly like this:
1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz

The only exception to this rule is constant output of your language's interpreter that cannot be suppressed, such as a greeting, ANSI color codes or indentation.
Further Rules

This is not about finding the language with the shortest approach for playing FizzBuzz, this is about finding the shortest approach in every language. Therefore, no answer will be marked as accepted.
Submissions are scored in bytes in an appropriate preexisting encoding, usually (but not necessarily) UTF-8. Some languages, like Folders, are a bit tricky to score--if in doubt, please ask on Meta.
Nothing can be printed to STDERR.
Feel free to use a language (or language version) even if it's newer than this challenge. If anyone wants to abuse this by creating a language where the empty program generates FizzBuzz output, then congrats for paving the way for a very boring answer.
Note that there must be an interpreter so the submission can be tested. It is allowed (and even encouraged) to write this interpreter yourself for a previously unimplemented language.
If your language of choice is a trivial variant of another (potentially more popular) language which already has an answer (think BASIC or SQL dialects, Unix shells or trivial Brainfuck derivatives like Alphuck and ???), consider adding a note to the existing answer that the same or a very similar solution is also the shortest in the other language.
Because the output is fixed, you may hardcode the output (but this may not be the shortest option).
You may use preexisting solutions, as long as you credit the original author of the program.
Standard loopholes are otherwise disallowed.

As a side note, please don't downvote boring (but valid) answers in languages where there is not much to golf; these are still useful to this question as it tries to compile a catalogue as complete as possible. However, do primarily upvote answers in languages where the authors actually had to put effort into golfing the code.
Catalogue

var QUESTION_ID=58615;var ANSWER_FILTER="!t)IWYnsLAZle2tQ3KqrVveCRJfxcRLe";var COMMENT_FILTER="!)Q2B_A2kjfAiU78X(md6BoYk";var OVERRIDE_USER=30525;var answers=[],answers_hash,answer_ids,answer_page=1,more_answers=true,comment_page;function answersUrl(index){return"https://api.stackexchange.com/2.2/questions/"+QUESTION_ID+"/answers?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+ANSWER_FILTER}function commentUrl(index,answers){return"https://api.stackexchange.com/2.2/answers/"+answers.join(';')+"/comments?page="+index+"&pagesize=100&order=desc&sort=creation&site=codegolf&filter="+COMMENT_FILTER}function getAnswers(){jQuery.ajax({url:answersUrl(answer_page++),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){answers.push.apply(answers,data.items);answers_hash=[];answer_ids=[];data.items.forEach(function(a){a.comments=[];var id=+a.share_link.match(/\d+/);answer_ids.push(id);answers_hash[id]=a});if(!data.has_more)more_answers=false;comment_page=1;getComments()}})}function getComments(){jQuery.ajax({url:commentUrl(comment_page++,answer_ids),method:"get",dataType:"jsonp",crossDomain:true,success:function(data){data.items.forEach(function(c){if(c.owner.user_id===OVERRIDE_USER)answers_hash[c.post_id].comments.push(c)});if(data.has_more)getComments();else if(more_answers)getAnswers();else process()}})}getAnswers();var SCORE_REG=/<h\d>\s*([^\n,<]*(?:<(?:[^\n>]*>[^\n<]*<\/[^\n>]*>)[^\n,<]*)*),.*?(\d+)(?=[^\n\d<>]*(?:<(?:s>[^\n<>]*<\/s>|[^\n<>]+>)[^\n\d<>]*)*<\/h\d>)/;var OVERRIDE_REG=/^Override\s*header:\s*/i;function getAuthorName(a){return a.owner.display_name}function process(){var valid=[];answers.forEach(function(a){var body=a.body;a.comments.forEach(function(c){if(OVERRIDE_REG.test(c.body))body='
'+c.body.replace(OVERRIDE_REG,'')+'
'});var match=body.match(SCORE_REG);if(match)valid.push({user:getAuthorName(a),size:+match[2],language:match[1],link:a.share_link,});else console.log(body)});valid.sort(function(a,b){var aB=a.size,bB=b.size;return aB-bB});var languages={};var place=1;var lastSize=null;var lastPlace=1;valid.forEach(function(a){if(a.size!=lastSize)lastPlace=place;lastSize=a.size;++place;var answer=jQuery("#answer-template").html();answer=answer.replace("{{PLACE}}",lastPlace+".").replace("{{NAME}}",a.user).replace("{{LANGUAGE}}",a.language).replace("{{SIZE}}",a.size).replace("{{LINK}}",a.link);answer=jQuery(answer);jQuery("#answers").append(answer);var lang=a.language;lang=jQuery(''+lang+'').text();languages[lang]=languages[lang]||{lang:a.language,lang_raw:lang.toLowerCase(),user:a.user,size:a.size,link:a.link}});var langs=[];for(var lang in languages)if(languages.hasOwnProperty(lang))langs.push(languages[lang]);langs.sort(function(a,b){if(a.lang_raw>b.lang_raw)return 1;if(a.lang_raw<b.lang_raw)return-1;return 0});for(var i=0;i<langs.length;++i){var language=jQuery("#language-template").html();var lang=langs[i];language=language.replace("{{LANGUAGE}}",lang.lang).replace("{{NAME}}",lang.user).replace("{{SIZE}}",lang.size).replace("{{LINK}}",lang.link);language=jQuery(language);jQuery("#languages").append(language)}}
body{text-align:left!important}#answer-list{padding:10px;width:290px;float:left}#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">

Shortest Solution by Language

Language	User	Score

Leaderboard

	Author	Language	Size

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

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

Nothing can be printed to STDERR.   Is this true only when running, or also when compiling (assuming that is a separate step?)

@AShelly Only when running

I’m not sure I like the fact that you hardcoded the 100 into the challenge. That way, a program that just generates the expected output is a valid entry, but is not interesting for this challenge. I think the challenge should expect the program to input the number of items to output.

@Timwi While I agree that it would make it (only slightly) more interesting, I've very often seen FizzBuzz as strictly 1 to 100 (on Wikipedia and Rosetta Code, for example). If the goal is to have a "canonical" FB challenge, it makes sense.

TI-BASIC's Disp outputs strings left-justified and numbers right-justified. Is that acceptable?

@ThomasKwa Yes, I would think so

A "vanilla fizzbuzz" sounds delicious.

QBasic outputs numbers with a leading space.  Is that acceptable?  (Workaround costs 14 bytes.)

What is that code snippet at the end of your answer? Is it automatically scrapping the page for answers?

@DavidGrinberg Yep, it gets the answers and puts them into the leaderboard :)

I can always add my Shakespearian reply, but since it barely counts as a "golfed code" (and SPL is nearly impossible to golf), perhaps it's best not to.

Related: High throughput Fizz Buzz for a version of this where performance is the winning condition, not code-size.

Can I have TWO trailing newlines?

The "FizzBuzz" string seems to be equivalent with "BuzzFizz", after all if a number is divisible by "3 and 5" it is also divisible by "5 and 3". Can I have such assumption and use "BuzzFizz" as a value for "divisible by 15?

Hexagony, 91 bytes
Thanks for the bounty :)
Wow, I would never have imagined I could beat Martin’s Hexagony solution.
But—who would have thunk it—I got it done. After several days of failure because I neither had the Hexagony colorer nor the EsotericIDE to check my solution. I got several aspects of the specification wrong, so I produced a few wrong “solutions” just using pen and paper and a text editor.
Well, finally I overcame my laziness and cloned both repositories, downloaded VisualStudio and compiled them. Wow, what useful tools they are! As you can see, I am far from being someone you’d call a programmer (I mean, come on! I didn’t even have VisualStudio installed, and have pretty much no clue about how to compile a program) ;)
It still took me a while to find a working solution, and it is quite crammed and chaotic, but here it is in all its glory:
Fizzbuzz in a size 6 hexagon:
3}1"$.!$>)}g4_.{$'))\<$\.\.@\}F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\;.z;i;..>(('

Hexagonal layout:
      3 } 1 " $ .
     ! $ > ) } g 4
    _ . { $ ' ) ) \
   < $ \ . \ . @ \ }
  F \ $ / ; z ; u ; <
 % < _ > _ . . $ > B /
  < > } ) ) ' % < > {
   > ; e " - < / _ %
    ; \ / { } / > .
     \ ; . z ; i ;
      . . > ( ( '

And the beautiful rendition, thanks to Timwi’s Hexagony Colorer:

So, here is a 110 seconds long GIF animation at 2 fps, showing the program flow during the first 6 numbers 1, 2, Fizz, 4, Buzz, Fizz, the first 220 ticks of the program (click on the image for the full size):

My goodness, thanks to the Natron compositing software the animation of the pointer was still tedious to create, but manageable. Saving 260 images of the memory was less amusing. Unfortunately EsotericIDE can’t do that automatically. Anyways, enjoy the animation!
After all, once you wrap your head around the memory model and the rather counterintuitive wrapping of paths that cross the borders of the hexagon, Hexagony is not that hard to work with. But golfing it can be a pain in the butt. ;)
It was fun!

Very nice! :) That's what I get for forgetting to try side-length 6 myself. ;) (Would be interesting to see if my solution fits into side-length 6 more easily though.)

@MartinBüttner I would love to see it :)

I am less of a programmer than you, because what is Visual Studio? :P

Unfortunately EsotericIDE can’t do that automatically. — Please go right ahead and file a feature suggestion, I might get around to doing that some day :)

(oops this comes up after 6 months of last reply) You may golf off 1 byte from the end of the program by shifting the grey path by 1 byte and placing a "Cancelling op" in the orange path like 3}1"$.!$>)}g4_'{$))}\<$\.\.@\;F\$/;z;u;<%<_>_..$>B/<>}))'%<>{>;e"-</_%;\/{}/>.\)(z;i;..>('.Now there is an extra ( after the z, which can be "cancelled" with a ) or by putting the z there.  Now it is a ) which pushes all commands on the orange path 1 tick later, and got back with the no-op that was on line 3. Btw I also installed Visual Studio just due to Hexagony Colorer and Esoteric IDE :P

Python 2, 56 bytes
i=0;exec"print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i;i+=1;"*100

Try it online!

Dang, that's bloody genius. Can I steal your idea to multiply the string by the mod-result?

@TimmyD Go ahead.

A different method for 56 (from here): i=1;exec"print'FizzBuzz'[i%-3&4:12&8-i%5]or i;i+=1;"*100. Anyone want to brute force search expressions to try to optimize the bit bashing?

@ETHproductions It does.

May I also steal your mod trick for a Ruby answer?

Very nice technique, I love the division of the modulo result to make it binary!  I have an improvement to get your method down to 54 chars...  Of course I wouldn't post it as an answer without your permission (since it's ~95% your answer) ;)

@Tersosauros Go ahead... my method is not very hard to find and has no doubt been independently discovered by many people.

@MickyT What? That's 91 bytes long and not even valid, as it would only work in a REPL.

My closest was 169 bytes: for x in range(1,101):m={0:'Fizz'}.get(x%3,'')+{0:'Buzz'}.get(x%5,'');print(m if m else x)

Total genius. The use of modulo to convert to binary. Still wrapping my brain around the solution. Awesome work.

It also works and comes out to 56 without the exec magic and the multiplied string, using a normal loop instead: for i in range(100):print i%3/2*'Fizz'+i%5/4*'Buzz'or-~i.

Can someone please explain how this actually works?

Labyrinth, 94 bytes
"):_1
\ } 01/3%70.105
" :   @ "     .
"  =";_""..:221
+  _
"! 5%66.117
_:= "     .
="*{"..:221

Sub-100! This was a fun one.
Explanation
Let's start with a brief primer on Labyrinth – feel free to skip this if you're already familiar with the basics:

Labyrinth has two stacks – a main stack and an auxiliary stack. Both stacks have an infinite number of zeroes at the bottom, e.g. + on an empty stack adds two zeroes, thus pushing zero.
Control flow in Labyrinth is decided by junctions, which look at the top of the stack to determine where to go next. Negative means turn left, zero means go straight ahead and positive means turn right... but if we hit a wall then we reverse direction. For example, if only straight ahead and turn left are possible but the top of the stack is positive, then since we can't turn right we turn left instead.
Digits in Labyrinth pop x and push 10*x + <digit>, which makes it easy to build up large numbers. However, this means that we need an instruction to push 0 in order to start a new number, which is _ in Labyrinth.

Now let's get to the actual code!

Red
Execution starts from the " in the top-left corner, which is a NOP. Next is ),  which increments the top of the stack, pushing 1 on the first pass and incrementing n on every following pass.
Next we duplicate n with :. Since n is positive, we turn right, executing } (shift top of main stack to auxiliary) and :. We hit a dead end, so we turn around and execute } and : once more, leaving the stacks like
Main [ n n | n n ] Aux

Once again, n is positive and we turn right, executing _101/ which divides n by 101. If n is 101 then n/101 = 1 and we turn into the @, which terminates the program. Otherwise, our current situation is
Main [ n 0 | n n ] Aux

Orange 1 (mod 3)
3 turns the top zero into a 3 (10*0 + 3 = 3) and % performs a modulo. If n%3 is positive, we turn right into the yellow ". Otherwise we perform 70.105.122:.., which outputs Fizz. Note that we don't need to push new zeroes with _ since n%3 was zero in this case, so we can exploit the infinite zeroes at the bottom of the stack. Both paths meet up again at light blue.
Light blue
The top of the stack is currently n%3, which could be positive, so the _; just pushes a zero and immediately pops it to make sure we go straight ahead, instead of turning into the @. We then use = to swap the tops of the main and auxiliary stacks, giving:
Main [ n | n%3 n ] Aux

Orange 2 (mod 5)
This is a similar situation to before, except that 66.117.122:.. outputs Buzz if n%5 is zero.
Dark blue
The previous section leaves the stacks like
Main [ n%5 | n%3 n ] Aux

{ shifts the n%3 back to the main stack and * multiplies the two modulos.
If either modulo is zero, the product is zero so we go straight into yellow. = swaps the top of the stacks and _ pushes a zero to make sure we go straight ahead, giving
Main [ n 0 | 0 ] Aux

Otherwise, if both modulos are nonzero, then the product is nonzero and we turn right into green. = swaps the tops of the stacks, giving
Main [ n | (n%5)*(n%3) ] Aux

after which we use : to duplicate n, turn right, then use ! to output n.
Purple
At this point, the main stack has either one or two items, depending on which path was taken. We need to get rid of the zero from the yellow path, and to do that we use +, which performs n + 0 in some order for both cases. Finally, \ outputs a newline and we're back at the start.
Each iteration pushes an extra (n%5)*(n%3) to the auxiliary stack, but otherwise we do the same thing all over again.

Loving the explanation.

Ruby, 50 bytes
Requires version 1.8, which seems to be popular among golfers:
1.upto(?d){|n|puts'FizzBuzz
'[i=n**4%-15,i+13]||n}

In modern Ruby, you replace ?d with 100 for a 51-byte solution.
This seems to be the world record.

That is diabolical, love it.

?d is just 100. The FizzBuzz string has a newline in it, this is valid in Ruby. string[i, s] is a slice, starting at character i (0-indexed), going on for s characters, ignoring indices pointing outside the string. If the argument to puts already has a newline, it is chopped off. The formula should be simple to read? It does all the work here. I wouldn't've found it without the help of some really pro Ruby golfers.

side note: if you were allowed to add 0 at the beginning of input(you're not), 2 bytes could be saved by using ?e.times instead.

Can you explain the [i=n**4%-15,i+13] part please? Can't seem to wrap my head around it

@Piccolo Does this snippet help? If i==-14 the slice is out of bounds so we get nil. If i==-9 we slice i+13==4 characters starting from the 9th character from the end, so 'Fizz'. If i==-5 we slice 8 characters starting from the 5th character from the end, so 'Buzz\n'. (We try to slice 8 but there are only 5, so we get 5.) Et cetera.

@Lynn Oh, that's really neat! Thank you!

With Ruby 2.7, a 50-character solution is once again possible: 1.upto(100){puts'FizzBuzz\n'[n=_1**4%-15,n+13]||_1}

1.upto(100){|i|puts'FizzBuzz '[n=i**4%-15,n+13]||i}

Perl 5, 49 bytes
46 bytes script + 3 bytes -E"..."
Using say (which requires -E"...") can reduce this further to 46 bytes since say automatically includes a newline (Thanks @Dennis!):
say'Fizz'x!($_%3).Buzz x!($_%5)||$_ for 1..100

Perl 5, 50 bytes
print'Fizz'x!($_%3).Buzz x!($_%5)||$_,$/for 1..100

You can save a few bytes by using say.

You broke the scoreboard...

@LegionMammal978 Yes. Yes I did... I'll try and re-word the title then! Argh!

Isn't -E"..." 8 bytes? Space + Dash + Option + Argument (+ Quoting).

@EriktheGolfer so since I posted this, the consensus is that -E is 0 bytes, but since primo's answer was scored excluding the quotes, I opted to make it fair and include the quotes in mine and +1 for -E. The reason it's accepted as free is Perl is usually run via perl -e and perl -E is no more bytes (I thought -M5.010 or use 5.010 can be free as well, but perhaps not re-reading the meta post). When adding -p or -n this is counted as +1 as you would run with perl -pe. Hope that helps! Meta reference: http://meta.codegolf.stackexchange.com/a/7539

gs2, 1
f

A quote from Mauris, the creator of gs2:

I wanted to one-up goruby's 1-byte Hello, world!, so... This prints "1\n2\nFizz\n4\nBuzz\n...". :)

Update: Added 27-byte answer that doesn't use f.

Java, 130 bytes
This is for recent Java versions (7+). In older ones you can shave some more off using the enum trick, but I don't think the logic gets any shorter than this (86 inside main).
class F{public static void main(String[]a){for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));}}

I don't think the initializer block trick helps here, since the question specifies empty stderr.

Hmm. I know the static trick prints to stderr, but I thought enum ran cleanly. Good to know :)

@Geobits I have created a Processing answer based of your Java answer.

beat me by 14 bytes! Using <1 instead of ==0 is a great way to save!

class F{public static -> interface F{static in java 8

That's not quite how enums work. You would have to do enum F{;public..., so you wouldn't actually be saving any bytes.

@HyperNeutrino The enum trick works if you add System.exit(0); at the end. Total length: 112 bytes. enum F{F;{for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));System.exit(0);}}. See my "Hello World" answer for details.

An interesting trick: The closing bracket in i++<100;) can also be moved to the other closing brackets near the end and it works the same (with the same byte count). But then you have one less smiley in your code. :(

JavaScript, 62 bytes
for(i=0;++i<101;console.log(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'

I think I this is the shortest Javascript solution now.

Wow, just wow! But all the other JS answers use console.log; it's much less annoying than having to press "OK" on 100 pop-up boxes in a row. Could you please change this? It'll only be 62 bytes, still three better than mine.

I'll have to do so tomorrow, as I have already edited 5 of my own posts and can't edit anymore...

Oh, I didn't realise there was a limit to editing...

So if I found a shorter answer that's similar to this, do I edit this or post a new answer? (it still uses console.log)

[...Array(99)].map((e,i)=>(((++i)%3?'':'Fizz')+((i)%5?'':'Buzz'))||i)

ArnoldC, 842 bytes
IT'S SHOWTIME
HEY CHRISTMAS TREE a
YOU SET US UP 100
HEY CHRISTMAS TREE b
YOU SET US UP 0
HEY CHRISTMAS TREE r
YOU SET US UP 0
STICK AROUND a
GET TO THE CHOPPER b
HERE IS MY INVITATION 101
GET DOWN a
ENOUGH TALK
GET TO THE CHOPPER r
HERE IS MY INVITATION b
I LET HIM GO 15
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE r
GET TO THE CHOPPER r
HERE IS MY INVITATION b
I LET HIM GO 3
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE r
GET TO THE CHOPPER r
HERE IS MY INVITATION b
I LET HIM GO 5
ENOUGH TALK
BECAUSE I'M GOING TO SAY PLEASE r
TALK TO THE HAND b
BULLSHIT
TALK TO THE HAND "Buzz"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
TALK TO THE HAND "Fizz"
YOU HAVE NO RESPECT FOR LOGIC
BULLSHIT
TALK TO THE HAND "FizzBuzz"
YOU HAVE NO RESPECT FOR LOGIC
GET TO THE CHOPPER a
HERE IS MY INVITATION a
GET DOWN 1
ENOUGH TALK
CHILL
YOU HAVE BEEN TERMINATED

First try at golfing, I think this is as bad as it gets (both language and golfing).

YOU HAVE NO RESPECT FOR LOGIC lol, this is a great language ;)

Hahahaha!!! You should've made it a method, worse bytecount, better phrases ;).

Apple Shortcuts, 9 actions

This creates a loop that runs 100 times. For each loop, it gets the iteration number and modulos it by 3. We then take the result and use regex replacement to change it to “Fizz” if it is 0. Then, we take the iteration number and use regex replacement to change it to “Buzz” if it ends in 0 or 5.
At this point, we have a value that is either “Fizz” or a number, and we have a value that is either “Buzz” or a number. We combine those two values together into a single string, and use regex replacement to remove any numbers. This leaves us with one of “Fizz”, “Buzz”, “FizzBuzz”, or an empty string. Finally, we use one more regex replacement to replace an empty string with the iteration number.
The final value left at the end of each iteration is added to the repeat results, so after the loop has finished running, we simply print the list of repeat results with a “show result” action, which automatically formats the list as a bunch of newline separated values.
For those who don’t want to/don’t know how to enter this code, here’s an iOS link that should hopefully maybe possibly work.

Pyth, 30
VS100|+*!%N3"Fizz"*!%N5"Buzz"N

Try it here
Explanation:
VS100|+*!%N3"Fizz"*!%N5"Buzz"N
VS100                            : for N in range(1,101)
     |                           : logical short-circuiting or
      +*!%N3"Fizz"               : add "Fizz" * not(N % 3)
                                 : Since not gives True/False this is either "" or "Fizz"
                  *!%N5"Buzz"    : Same but with 5 and Buzz
                             N   : Otherwise N
                                 : The output of the | is implicitly printed with a newline

Retina, 317 139 134 132 70 63 60 55 bytes
.100{`^
_
*\(a`(___)+
Fi;$&
\b(_{5})+$
Bu;
;_*
zz
'_&`.

Try it online!
Explanation
.100{`^
_

The . is the global silent flag which turns off implicit output at the end of the program. 100{ wraps the rest of the program in a loop which is executed for 100 iterations. Finally, the stage itself just inserts a _ at the beginning of the string, which effectively increments a unary loop counter.
*\(a`(___)+
Fi;$&

More configuration. *\( wraps the remainder of the program in a group, prints its result with a trailing linefeed, but also puts the entire group in a dry run, which means that its result will be discarded after printing, so that our loop counter isn't actually modified. a is a custom regex modifier which anchors the regex to the entire string (which saves a byte on using ^ and $ explicitly).
The atomic stage itself takes care of Fizz. Divisibility by 3 can easily be checked in unary: just test if the number can be written as a repetition of ___. If this is the case, we prepend Fi; to the string. The semicolon is so that there is still a word boundary in front of the number for the next stage. If we turned the line into Fizz___... the position between z and _ would not be considered a boundary, because regex treats both letters and underscores as word characters. However, the semicolon also allows us to remove the zz duplication from Fizz and Buzz.
\b(_{5})+$
Bu;

We do the exact same for divisibility by 5 and Bu;, although we don't need to keep the _s around this time. So we would get a results like
_
__
Fi;___
____
Bu;
Fi;______
...
Fi;Bu;
...

This makes it very easy to get rid of the underscores only in those lines which contain Fizz, while also filling in the zzs:
;_*
zz

That is, we turn each semicolon into zz but we also consume all the _s right after it. At this point we're done with FizzBuzz in unary. But the challenge wants decimal output.
'_&`.

& indicates a conditional: this stage is only executed if the string contains an underscore. Therefore, Fizz, Buzz and FizzBuzz iterations are left untouched. In all other iterations (i.e. those which are neither divisible by 3 nor 5), we just count the number of characters, converting the result to decimal.

brainfuck, 206 bytes
++>+++++>>>>>++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]>
[+[[<<]<[>>]+++<[<.<.<..[>]]<<-[>>>[,>>[<]>[--.++<<]>]]+++++<[+[-----.++++<<]>>+
..<-[>]]<[->>,>+>>>->->.>]<<]<[>+<<<,<->>>+]<]

Formatted:
++>+++++>>>>>
++++++++++[>+>>+>>+>+<<<[++++<-<]<,<,-<-<++<++++[<++>++++++>]++>>]
>
[
  +
  [
    [<<]
    <[>>]
    +++<
    [
      Fizz
      <.<.<..
      [>]
    ]
    <<-
    [
      >>>
      [
        ,>>[<]
        >[--.++<<]
        >
      ]
    ]
    +++++<
    [
      Buzz
      +[-----.++++<<]
      >>+..
      <-
      [>]
    ]
    <[->>,>+>>>->->.>]
    <<
  ]
  <[>+< <<,<->>>+]
  <
]

Try it online
The memory layout is
0 a 122 105 70 b f 0 t d1 s d2 c d 10 0

where f cycles by 3, b cycles by 5, d1 is ones digit, d2 is tens digit, s is a flag for whether to print tens digit, d cycles by 10, c is copy space for d, t is working space that holds 0 or junk data or a flag for not-divisible-by-3, and a determines program termination by offsetting the pointer after Buzz has been printed 20 times.

For some reason on code.golf this code bugs :/

Vyxal, j, 65 bits1,  18 17 14 12 11 8.125 bytes
₁ƛ₍₃₅kF½*∑∴

Try it Online! (link is to bitstring)
I refuse to be beaten by Arn, Ash and Fig. I absolutely will not be beaten by any of those languages. Vyxal forever lads.
And yes, that really is 8.125 bytes. We have a fractional byte encoding system now. The 65-bit bitstring can be found at the online link.
The program is presented as SBCS for convenience.
Explained
₁ƛ₍₃₅kF½*∑∴
₁           # Push 100 to the stack
 ƛ          # Over the range [1, 100], map: (we'll call the argument n)
  ₍₃₅       #   [n % 3 == 0, n % 5 == 0] (call this X)
     kF     #   "FizzBuzz"
       ½    #   ["Fizz", "Buzz"] # halve the string - split into two equal pieces
        *∑  #   sum(X * ↑)
          ∴ #   max(↑, n)
            # The -j flag joins on newlines before outputting

If you want it flagless:
Vyxal, 12 bytes
₁⟑₍₃₅kF½*∑∴,

Try it Online!
See how inconsequential flags are?
Vyxal, 17 bytes
₁⟑35fḊ`₴ḟȦ↑`½*∑∴,

No questionable built-ins, no flags, just plain legitimate fizzbuzz.
Try it Online!

Finally!! Vyxal!

@HighlyRadioactive I thought I'd introduce it in the best way possible: beating Dennis

Dennis (comes back): :(

@petStorm that isn't implemented yet

@petStorm it's implemented now

I don't think it counts as beating anyone if the language was designed after the challenge

There's a debate to be had about whether it means anything for an answer to beat or be beaten by an answer in a different language, but the age of the language should be irrelevant in that determination.

The Jelly chain syntax is cluttered with unnecessary syntactical elements, so it's going to be quite easy to beat it with less cluttered language.

What does the M flag do?

@Lynn it makes the map-lambda go from [1, n] rather than [0,n)

I see. Well... I know how meta counts flags, but I'm not sure how sportsmanlike it is to compare your language (and say you "legitimately beat Dennis") to Jelly, which has no such flags, without counting the flags. You're basically tucking an implicit "increment" and "join by NL" instruction into the program flags, and then counting two fewer bytes.

Ahh nice, you made an implicit operand for ⟇!

How does kF½ translate to ["Fizz", "Buzz"]?

Split the string "FizzBuzz" in two equal pieces (halve it)

Plus the fact you have so many FizzBuzz builtins... one for "is this a Fizz number", one for "is this a Buzz number" and of course a (two-byte) builtin for "FizzBuzz" itself. Without those you'd be over 20 bytes for sure.

@Neil actually I'd be at 18, which is what I originally had

Sorry, still using FizzBuzz builtins.

Well, at least I know Arn would be tied with you if you didn't use builtins ;)

It seems to have BuzzFizz rather than FizzBuzz for multiples of 15. Is that allowed?

5 bytes with extremely questionable builtins. also the 11-byter can be 10 with H flag

In what encoding can I save this to get 11 bytes? Don't tell me there is a Vyxal encoding? :D

@weltensturm well actually, there is a vyxal encoding. It has its own SBCS, as do many golfing languages today

Perl 5, 45 bytes
say((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

Requires the -E option, counted as one. This must be run from the command line, i.e.:
perl -Esay((Fizz)[$_%3].(Buzz)[$_%5]or$_)for+1..100

Quotes around the command are unnecessary, if one avoids using spaces, or any other characters which can act as command line separators (|, <, >, &, etc.).

Perl 5, 48 bytes
print+(Fizz)[$_%3].(Buzz)[$_%5]||$_,$/for 1..100

If command line options are counted as one each, -l would save one byte (by replacing $/). By Classic Perlgolf Rules, however, this would count 3: one for the -, one for the l, and one for the necessary space.

You can use say, with the -E switch, which has edit distance 1 to -e, so it should count as 1 byte.

Hey primo, I feel like I'm cheating in my answer for using say, I've assumed that -E can be used in place of -e which would bring you down to 44 rather than 46. I don't think it's fair that I'm scoring differently to you, what's the preferred scoring mechanism? I generally use print to avoid this! Closest to a consensus would be this?

My personal take is that every additional byte on the command line should score 1. In particular for say, if your code can be written on one line avoiding any OS separators, score 1 for -E. If you need to use quotes, e.g. -E"$a||$b", score 3. If you can't get it on one line, score 5 for -M5.01. But at that point you'd probably be better off using -l. I don't agree that it should be free by default, for two reasons: 1) the improvement is trivial and uninteresting, and 2) there is no version of the interpreter for which it is enabled by default.

><>, 68 66 65 64 63 bytes
1\2+2fooo o"Buzz"<
o>:::3%:?!\$5%:?!/*?n1+:aa*)?;a
o.!o"Fizz"/o

The only trick is to multiply remainders as a condition to number printing. That way, if one of them is 0 we won't print the number.
You can try it here.
Saved one byte thanks to Sp3000, another thanks to randomra, and a last one thanks to Jacklyn. Thanks a lot!

Very well golfed, I love the reuse of the "" on the first line and the one on the second line.

-1 byte if you move the o at end of the second line to the empty space at the start of the line, I believe.

@Sp3000 Indeed, I spent so much time golfing this I don't know how this did not come to mind

Who needs fizz buzz when you can have foooo Buzz?

Another small optimization: you can delete the o at the end of the 3rd line, and then change the spacing from oooo "Buzz" to ooo o"Buzz" to save 1 byte

@Jacklynn hey thanks, I've edited it in. I didn't think it could still be improved upon so long after I came up with it !

You may want to update your link since fishlanguage.com has gone down. You can use the (slightly buggy) clone at https://suppen.no/fishlanguage, or use TIO

i'll also note that we over at code.golf have got it down to 49 bytes (or 51 with proper termination) if you want to have a goal to aim for

@JoKing thanks, I've updated the link. Sadly not much motivation to code outside of work nowadays, but if it comes back I hope I'll remember code.golf !

beeswax, 104 89 81 bytes
Denser packing allowed for cutting off 8 more bytes.
Shortest solution (81 bytes), same program flow, different packing.
p?@<
p?{@b'gA<
p@`zzuB`d'%~5F@<f`z`<
 >~P"#"_"1F3~%'d`Fiz`b
 d;"-~@~.<
>?N@9P~0+d

Changing the concept enabled me to cut down the code by 15 bytes.
I wanted to get rid of the double mod 5 test in the solution, so I implemented a flag.
Short explanation:
if n%3=0 Fizz gets printed, and the flag gets set. The flag is realized simply by pushing the top lstack value onto the gstack (instruction f).
If n%5=0, then either n%3=0(FizzBuzz case) or n%3>0(Buzz case). In both cases, Buzz gets printed, and the flag reset by popping the stack until it’s empty (instruction ?).
Now the interesting cases:
If n%5>0, then either we had n%3=0 (printing Fizz case, n must not be printed) or n%3>0 (Fizz was not printed, so n has to be printed). Time to check the flag. This is realized by pushing the length of gstack on top of gstack (instruction A).
If n%3 was 0 then the gstack length is >0.
If n%3 was >0, the gstack length is 0.
A simple conditional jump makes sure n gets only printed if the length of gstack was 0.
Again, after printing any of n, Fizz, and/or Buzz and the newline, the gstack gets popped twice to make sure it’s empty. gstack is either empty [], which leads to [0] after instruction A (push length of gstack on gstack), or it contains one zero ([0],the result of n%3), which leads to [0 1], as [0] has the length 1. Popping from an empty stack does not change the stack, so it’s safe to pop twice.
If you look closer you can see that, in principle, I folded
>      q
d`Fizz`f>

into
<f`z`<
d`Fiz`b

which helps to get rid of the all the wasted space between A and < at the end of the following row in the older solution below:
q?{@b'gA<       p      <

New concept solution (89 bytes) including animated explanation:
q?@ <
 q?{@b'gA<       p      <
p?<@`zzuB`b'%~5F@<f`zziF`b'<
>N@9P~0+.~@~-";~P"#"_"1F3~%d

Hexagonal layout:
   q ? @   <
    q ? { @ b ' g A <               p             <
 p ? < @ ` z z u B ` b ' % ~ 5 F @ < f ` z z i F ` b ' <
> N @ 9 P ~ 0 + . ~ @ ~ - " ; ~ P " # " _ " 1 F 3 ~ % d

Animation of the first 326 ticks at 2 fps, with local and global stacks, and output to STDOUT.

For comparison, below are the path overlays of the older, more complex solution. Maybe it’s also the prettier solution, from a visual standpoint ;)

This is as crazy and beautiful as Hexagony. Have a +1!

@ETHproductions I still need to give Hexagony a try, but from what I can tell from the language specs, my beeswax doesn’t even come close to the craziness of Hexagony.

Let us continue this discussion in chat.

How are you making those animations?

gs2, 28 27 (without f)
Hex:
1b 2f fe cc 04 46 69 7a 7a 09 07 42 75 7a 7a 19 06 27 2d d8 62 32 ec 99 dc 61 0a

Explanation:
1b    100
2f    range1 (1..n)
fe    m: (map rest of program)

cc    put0 (pop and store in register 0)
04    string-begin
Fizz
09    9
07    string-separator
Buzz
19    25
06    string-end-array (result: ["Fizz"+chr(9) "Buzz"+chr(25)])

27    right-uncons
2d    sqrt
d8    tuck0 (insert value of register 0 under top of stack)
62    divides
32    times (string multiplication)
ec    m5 (create block from previous 5 tokens, then call map)

99    flatten
dc    show0 (convert register 0 to string and push it)
61    logical-or
0a    newline

Embedding 3 and 5 into the string constant doesn't work because \x05 ends string literals.
Note: This problem can be solved in 1 byte with gs2 using the built-in f.

C, 74 bytes
main(i){for(;i<101;puts(i++%5?"":"Buzz"))printf(i%3?i%5?"%d":0:"Fizz",i);}

The 0 argument to printf instead of "" is fishy, but seems to work on most platforms I try it on. puts segfaults when you try the same thing, though. Without it, you get 75 bytes.
There are 73-byte solutions that work on anarchy golf, and I found one digging around in the right places on the internet, but they rely on platform-specific behavior. (As you might have guessed, it's something of the form puts("Buzz"±...).)

Nice trick to get i=1 for the no args case (argc=1).  It's a feature: you can start the sequence from any point by running ./fizzbuzz $(seq 40) :P

this can be trivially ported to c++ by adding the necessary boilerplate

it seems to segfault in TIO

As c-- mentioned, this segfaults on TIO

Scratch, 203 185 bytes

Bytes counted from the golfed textual representation, per this meta post. Scratch is not very space-efficient.
say is the closest thing to a stdout Scratch has: the sprite displays a speech bubble containing whatever it is saying. In practice, a wait n secs block would be needed to actually read this output, but for the purposes of this challenge this code fulfills the requirements.

You're missing numbers after the y = (in both occurrences)

@BetaDecay Sorry? I don't follow.

Inside the repeat loop, the set y to ... is missing a value

@BetaDecay That's the empty string. :) if you click on the image, you can view it in action!

Ohhh haha sorry for doubting you ;)

Nice one. I've never seen a Scratch solution before. :)

Never thought Scratch solution will show up here. So awesome to see this. Great work @timothymh

There’s a block called “for each x in (number)”. It could save a few bytes, although it’s kind of hard to get it since they removed it from the menu. It does the same thing as the repeat 100 and chance x by 1 blocks. You might be able to get by backpacking it from some other scratch codegolf challenges.

Jelly, 24 20 bytes
³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G

Try it online!
How it works
³µ3,5ḍTị“¡Ṭ4“Ụp»ȯµ€G  Main link. No input.

³                     Yield 100.
 µ                    Begin a new, monadic chain.
                 µ€   Apply the preceding chain to all integers n in [1, ..., 100].
  3,5ḍ                Test n for divisibility by 3 and 5.
      T               Get all truthy indices.
                      This yields [1] (mult. of 3, not 5), [2] (mult. of 5, not 3),
                      [1, 2] (mult. of 15) or [].
        “¡Ṭ4“Ụp»      Yield ['Fizz', 'Buzz'] by indexing in a dictionary.
       ị              Retrieve the strings at the corr. indices.
                ȯ     Logical OR hook; replace an empty list with n.
                   G  Grid; join the list, separating by linefeeds.

again nobody out golfed dennis (except for the HQ9+ style answer)

@noɥʇʎԀʎzɐɹƆ but now they have.

µ€ is now known as ), saving a byte.

@Lyxal It seems that you're right... ^ Lynn has out golfed Dennis in the comment above.

C, 85 bytes
i;main(){for(;i++<=99;printf("%s%s%.d\n",i%3?"":"Fizz",i%5?"":"Buzz",(i%3&&i%5)*i));}

-2 thanks to squeamish.

Global variables are initialized to zero, so instead of main(i), try i;main(). Then you can get rid of the i-- at the start of the for() loop. You don't need the line break either. That should bring the byte count down to 85.

Found a way to shave one more byte:
main(i){for(;printf("%s%s%.d\n",i%3?"":"Fizz",i%5?"":"Buzz",(i%3&&i%5)*i),99/i++;);}

So it should be 84 bytes now. (I wanted to add this to my other comment but edit timed out)

printf(i%5?i%3?"%d\n":"Fizz\n":i%3?"Buzz\n":"FizzBuzz\n",i) saves another byte, can be combined with @TobErnack's comment.

Depending on how UB you want to get, you can do 73, 74, or 75 bytes. Here's my 74 byte answer.

Feel like there is something you can do with the double "zz" in fizz and buzz haha

OMG I spent maybe 3 hours trying to get this thing just one byte smaller. Here you go. Replace (i%3&&i%5)*i with i%3*i%5?i:0 I'm going to bed

Haskell, 84 82 bytes
main=mapM putStrLn[show n`max`map("FizzBuzz"!!)[6-2*gcd 3n..2+gcd 5n]|n<-[1..100]]

The expressions work out like this:
 n   6-2*gcd(3,n)  2+gcd(5,n)
=============================
 1        4             3
 2        4             3
 3       *0             3
 4        4             3
 5        4            *7
 6       *0             3
 7        4             3
 8        4             3
 9       *0             3
10        4            *7
11        4             3
12       *0             3
13        4             3
14        4             3
15       *0            *7
16       ...           ...

We use them as start and end points for slicing the string. For example, when n == 5, then map("FizzBuzz"!!)[4..7] == "Buzz".
For non-divisible numbers, the range [4..3] is empty, so the result of map is "", and max (show n) replaces that result.
Old 84 byte answer
main=mapM f[1..100]
f n|d<-drop.(*4).mod n=putStrLn$max(show n)$d 3"Fizz"++d 5"Buzz"

d = drop.(*4).mod n is key here: d 3 "Fizz" is drop (n`mod`3 * 4) "Fizz". This is "Fizz" when n `mod` 3 is 0 and "" otherwise.
Other stuff
I got here via this 85:
main=mapM putStrLn[max(show n)$drop(6-2*gcd 3n)$take(3+gcd 5n)"FizzBuzz"|n<-[1..100]]

Here is another interesting 85:
f n=cycle[show n,"Fizz","Buzz",f 3++f 5]!!div(gcd 15n)2
main=mapM(putStrLn.f)[1..100]

The world record is 80 bytes by henkma.

Rearrangement golfs it down to 82, I think: (%)=drop.(*4).mod n;main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100]].

Wait, then n isn't in scope. Hm.

Yeah, that doesn't work, but I've hit an alternative 85-byte solution that looks a lot like it: main=mapM putStrLn[max(show n)$3%"Fizz"++5%"Buzz"|n<-[0..100],(%)<-[drop.(*4).mod n]]

Why not use a line break? It's just as short as a semicolon but less unreadable.

@dfeuer I remember I was trying lots of different FizzBuzz approaches, and I wrote them all as one-liners in a single file to easily compare their lengths.

Could you change it now? Horizontal scrolling is especially rough on mobile devices.

I suggest you reconsider your quest for readable code on a code golf website :)

Whoops.... That down vote was mine, and entirely accidental.

@dfeuer I found a shorter solution, so you can fix your downvote if you'd like.

CJam, 35 bytes
100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/

Try it online in the CJam interpreter.
How it works
100{)_[Z5]f%:!"FizzBuzz"4/.*s\e|N}/
100{                             }/  For each integer I between 0 and 99:
    )_                                 Increment I and push a copy.
      [Z5]                             Push [3 5].
          f%                           Map % to push [(I+1)%3 (I+1)%5].
            :!                         Apply logical NOT to each remainder.
              "FizzBuzz"4/             Push ["Fizz" "Buzz"].
                          .*           Vectorized string repetition.
                            s\         Flatten the result and swap it with I+1.
                              e|       Logical OR; if `s' pushed an empty string,
                                       replace it with I+1.
                                N      Push a linefeed.

More straightforward solution: 100{):I3%!"Fizz"*I5%!"Buzz"*+Ie|N}/

PowerShell, 78 68 61 54 51 Bytes
(-1 byte thanks to a person on Twitter that explicitly started following me just to tag me in a Tweet with a golf, because they don't use SE. I was able to improve on that with a bit more of a golf. But since it requires the new ternary operator in pwsh 7, I'm leaving the old versions present lower down.)
1..100|%{($x="Fizz"*!($_%3)+"Buzz"*!($_%5))?$x :$_}

Loops from 1 to 100, each time constructing $x by exploiting implicit Boolean conversion. That is, if $_%3 is 0, it gets converted to $true with the !, then the * re-converts it to a 1 so that we add on "Fizz" to $x. We encapsulate that construction in parens, so we can re-use it as the introductory query to the ternary operator, choosing to either output $x or $_, depending on whether $x is present.
Normally here is where I'd link it to Try It Online, but that's still on pwsh Core 6.2.3, so doesn't have the ternary operator.

Pre-pwsh 7
1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]}

Edit: Saved 10 bytes thanks to feersum
Edit2: Realized that with feersum's trick, I no longer need to formulate $t as a string-of-code-blocks
Edit3: Saved another 7 bytes thanks to Danko Durbić
Similar-ish in spirit to the stock Rosetta Code answer, but golfed down quite a bit.
Explanation
1..100|%{...} Create a collection of 1 through 100, then for-each object in that collection, do
(...,$_) create a new collection of two elements:
0) $t=... set the variable $t equal to a string;

$_ our-current-number of the loop

"Fizz"*!($_%3) take our-current-number, mod it by 3, then NOT the result. Multiply "Fizz" by that, and add it to the string (and similar for 5). PowerShell treats any non-zero number as $TRUE, and thus the NOT of a non-zero number is 0, meaning that only if our-current-number is a multiple of 3 will "Fizz" get added to the string.
[!$t] indexes into the collection we just created, based on the value of the string $t -- non-empty, print it, else print our-current-number

Alternatively, also 54 bytes
1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_}

Thanks to TesselatingHeckler
Similar in concept, this uses the inline -replace operator and a regular expression to swap out an empty string ^$ with our-current-number. If the string is non-empty, it doesn't get swapped.

Alternatively, also 54 bytes
1..100|%{($_,('Fizz'*!($_%3)+'Buzz'*!($_%5))|sort)[1]}

This is the same loop structure as above, but inside it sorts the pair (n, string), and relies on the fact that an empty string sorts before a number, but a FizzBuzz string sorts after a number. Then it indexes the second sort result.

As an aside, if PowerShell ever implemented the || operator, like in C#, we could likely get down to 43 bytes with something similar to 1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)||$_} ... doubtful, since the | is such an important special operator in PowerShell, but I can dream ...

How about 1..100|%{'Fizz'*!($_%3)+'Buzz'*!($_%5)-replace'^$',$_} for 54?

You can replace if($t){$t}else{$_} with something like ($t,$_)[!$t]

... so you get 1..100|%{(($t="Fizz"*!($_%3)+"Buzz"*!($_%5)),$_)[!$t]} which is also 54 like @TessellatingHeckler's suggestion

@TessellatingHeckler PowerShell is nothing if not flexible.

MUMPS, 56 54 bytes
f i=1:1:100 w:i#5=0 "Fizz" w:i#3=0 "Buzz" w:$X<3 i w !

What's this w:$X<3 i thing, you ask? $X is a magic variable (an "intrinsic") that stores the horizontal position of the output cursor (as a number of characters from the left edge of the terminal). w is the abbreviated form of the WRITE command. The syntax command:condition args is a postconditional - "if condition, then do command args".
So we're checking whether the output cursor has been advanced more than two characters (which would mean that at least one of "Fizz" or "Buzz" has been written to the terminal), and if not, writing i to the terminal. The $X variable - and hence, this sort of deep inseparability from the terminal - is a first-class feature of MUMPS. Yikes.

C#, 128 126 125 124 bytes
class A{static void Main(){for(var i=0;i++<100;)System.Console.Write("{0:#}{1:;;Fizz}{2:;;Buzz}\n",i%3*i%5>0?i:0,i%3,i%5);}}

89 bytes without the boilerplate code around.
Done with the use of C#'s conditional formatting.
With two section separators ;, Fizz or Buzz are printed if the value from their condition is zero.

Saved a total of 4 bytes thanks to @RubberDuck, @Timwi and @Riokmij.

It would be shorter to call Write and append the newline directly to the string, right?

It’s also one byte shorter to write i%3*i%5>0?i:0 instead of i%3*i%5==0?0:i.

You can save another byte on the for statement by using for(var i=0;i++<100;)

@LegionMammal978 No, it cannot, it would hide the i only on multiple of 15, instead of 3, 5 and 15.. You can try it.

This skips number 1.  Start form i=0.

@Hand-E-Food Oh, indeed! I forgot to change that part while doing the improvement suggested by Riokmij. Thanks!

You can save three more bytes by leveraging String Interpolation from C#6.0 and embedding the format arguments into the string itself (e.g. $"{(i%3*i%5>0?i:0):#}...\n")

Live code for this http://csharppad.com/gist/c235498d6c042476664420a1b5ab0e7b

can do with 121 bytes today - class A{static void Main(){for(var i=0;i<100;)System.Console.Write($"{(++i%3*i%5<1?0:i):#}{i%3:;;Fizz}{i%5:;;Buzz}\n");}}

Using C#9 top-level statements it can be reduced to this for(var i=0;i<100;)System.Console.Write($"{(++i%3*i%5<1?0:i):#}{i%3:;;Fizz}{i%5:;;Buzz}\n"); - 92 bytes

Clojure, 113 106 101 100 91 bytes
My first golf!
(dotimes[i 100](println(str({2'Fizz}(mod i 3))({4'Buzz}(mod i 5)({2""}(mod i 3)(inc i))))))

Ungolfed:
(dotimes [i 100] ; account for off-by-one later
  (println (str ({2 'Fizz} ; str converts symbols to strings
                 (mod i 3))
                ({4 'Buzz} ; 4 instead of 0 because of off-by-one
                 (mod i 5)
                 ({2 ""} ; shortest way to write when-not
                  (mod i 3)
                  (inc i))))))

You can remove 5 characters by handling the println the same way as in the Java solution, eg. (doall(map #(let[t(=(mod % 3)0)](println(str(if t"Fizz""")(if(=(mod % 5)0)"Buzz"(if t""%)))))(range 1 101)))

@resueman Thanks! It actually ended up being 7, because (if t"Fizz""") can be simplified to (if t"Fizz"). :)

+1 Nice modulo trick, at first I though you had off-by-one errors.

Hexagony, 112 bytes
d{$>){*./;\.}<._.zi...><{}.;/;$@-/=.*F;>8M'<$<..'_}....>.3'%<}'>}))'%<..._>_.'<$.....};u..}....{B.;..;.!<'..>z;/

After unfolding and with colour-coded execution paths:

Diagram created with Timwi's HexagonyColorer.
Finally got around to finishing this. I had written an ungolfed solution weeks ago, but wasn't entirely happy with it so I never actually golfed it. After revisiting it the other day, I found a way to simplify the ungolfed solution slightly, and while I think there might still be a better way to approach the problem in general, I decided to golf it this time. The current solution is far from optimal, and I think it should actually fit in side-length 6 instead of 7. I'll give this a go over the next days, and when I'm happy with the result will add a full explanation.

That execution is a mess :P

@LegionMammal978 I've seen worse. ;)

How do you create those diagrams?

@LegionMammal978 Oh, I forgot to add the usual credits: https://github.com/Timwi/HexagonyColorer

brainfuck, 411 350 277 258 bytes
Edits:

-61 bytes by storing the values of "Fizz Buzz" as "BuziF" "BuziG" and redoing the number printing section.

-71 bytes by redoing the modulo number printing section, splitting the loop counter and the number counter, and reusing the newline cell as the mod value, among other things

-19 bytes by realising that there aren't any 0s in any FizzBuzz numbers. Also added explanation

+[-[>+<<]>-]>--[>+>++>++>++++++>+>>>++++++[<<<]>-]<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>>[>+<<<-[<]<[>+++>+<<-.+<.<..[<]<]>>-[<<]>[.>.>..>>>>+[<]+++++<]>[>]>>[[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>[-<+>]>,>[>]<[>-[<+>-----]<---.,<]++++++++++>]<.<<<<,>-]
Try it online!
Instead of checking if the number itself was divisible by 5 or 3 I had two counters keeping track of the modulo of the number, decrementing them for each number and printing out the corresponding word when they reached 0.
How It Works:
+[-[>+<<]>-]>--  Generate the number 61
[>+>++>++>++++++>+>>>++++++[<<<]>-] Set the tape to multiples of 61
TAPE: 0 0' 61  122 122 110 61  0 0 110
           "=" "z" "z" "n" "="
<+++++[>+>+>->>->++>>>-->>>++[<<<]>>>-]>[>]+++>> Modify values by multiples of 5
TAPE: 0' 5 66  117 122 105 71  3 0 100' 0 0 10
           "B" "u" "z" "i" "G"
Some info:
  5     - Buzz counter
  "Buz" - Buzz printing
  "ziG" - Fizz printing. Modifying the G in the loop is shorter than modifying it outside
  3     - Fizz counter
  0     - This is where the Fizz|Buzz check will be located
  100   - Loop counter
  0     - Number counter. It's not worth it to reuse the loop counter as this.
  0     - Sometimes a zero is just a zero
  10    - Value as a newline and to mod the number by

[ Loop 100 times
  >+<<<  Increment number counter
  -[<]<  Decrement Fizz counter
  [ If Fizz counter is 0
    >+++ Reset the Fizz counter to 3
    >+<< Set the Fizz|Buzz check to true
    -.+<.<.. Print "Fizz"
  [<]<] Sync pointers
  >>-[<<]> Decrement Buzz counter
  [ If Buzz counter is 0
    .>.>.. Print "Buzz"
    >>>>+  Set the Fizz|Buzz check to true
    [<]+++++< Reset the Buzz counter to 5
  ]
  >[>]>> Go to Fizz|Buzz check
  [ If there was no Fizz or Buzz for this number
    TAPE: 3% BuziG 5% 0 Loop Num' 0 10
    [->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]  Mod the number counter by 10
    TAPE: 3% BuziG 5% 0 Loop 0' Num 10-Num%10 Num%10 Num/10
    >[-<+>] Move Num back in place
    >,>[>]< Reset 10-Num%10
    [ For both Num/10 (if it exists) and Num%10
      >-[<+>-----]<--- Add 48 to the number to turn it into the ASCII equivilent
      .,< Print and remove
    ]
    ++++++++++> Add the 10 back
  ]
  <. Print the newline
  <<<<, Remove Fizz|Buzz check
  >- Decrement Loop counter
]

Well done Jo! I might try to beat that someday :)

R, 88 83 77 71 70 bytes
I'm sure that this can be improved ... and it was with credit to @flodel. A further couple of bytes saved thanks to a suggestion from @njnnja and another from @J.Doe
x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1)

A cat answer. The mouse is above :)

I found a bit better: x=1:100;i=!x%%3;j=!x%%5;x[i]="Fizz";x[j]="Buzz";x[i&j]="FizzBuzz";cat(x,sep="\n")

@njnnja  Thanks for the suggestion.  I implemented it with a write rather than cat though

Necromancy here! The write call can take a 1 instead of a an empty string so x=y=1:100;y[3*x]='Fizz';y[5*x]='Buzz';y[15*x]='FizzBuzz';write(y[x],1) is a trivial 1 byte golf for 70 bytes.

68 bytes. The bytecount includes three unprintable backspaces, and it doesn't work correctly in TIO.

@J.Doe I like the use of backspaces in this, but I think it may not be  acceptable based on this meta and the statement in the rules " ... Because the output is fixed ... ".  Still nice job

Oh well, it was worth a try! If escape characters are disallowed in this kind of challenge, then I guess 70 bytes is rock bottom.

Vim, 44 bytes
33o<CR>Fizz<CR><Esc>qqABuzz<Esc>5kq19@q:%s/^$/\=line('.')<CR>
On vimgolf.com we have the classic Remember FizzBuzz?, which is similar to this, but keeps the numbers on all the lines. There's also Neither Fizz nor Buzz, which uses a similar format, but provides a useful input file. Those small differences drastically change the optimal solution. I did exactly this same variation 2 years ago in the edit to this reddit post. I had to check whether visual increment (not available back then) creates an improvement, like it has for the other variations, but it looks like it hasn't.

33o<CR>Fizz<CR><Esc>: Create the Fizz lines AND the blank lines with a simple insert mode repeat. Much quicker than a macro. AFAIK first discovered by @KersonHsiao in the vimgolf.com version, and used by every top solution since.
qqABuzz<Esc>5kq19@q: A very simple macro appends the Buzzes.
:%s/^$/\=line('.')<CR>: Replaces all blank lines with that line's line number. The expression replacement is very long, so this tactic is rarely used in vimgolf, but the alternatives are all worse.

PHP, 54 bytes
<?for(;$i++<100;)echo[Fizz][$i%3].[Buzz][$i%5]?:$i,~õ;

Valid for v5.5 onwards. The õ is character 245, a bit inverted \n.
I assume the default interpreter settings, as they are without any ini. If you are uncertain, you may disable your local ini with -n as in php -n fizzbuzz.php.
A version which will run error-free with absolutely any configuration file is 62 bytes:
<?php
for(;$i++<100;)echo@([Fizz][$i%3].[Buzz][$i%5]?:$i),"
";

The STFU operator @ does not necessarily mean that the code is error free.

https://ideone.com/5rfNt0

@Kzqai http://ideone.com/0zRA9e short_open_tag is off, E_NOTICE is on. Neither of these are default settings.

I'm getting a bunch of errors on 3v4l.org

@acoder relevant meta post. 3v4l.org seems useful.

Save two bytes: use -r and remove the tag.

@Titus From the description: "Write a program." I understand that many people in this community have chosen to willfully misinterpret this.

80386 machine code + DOS, 75 bytes
Hexdump of the code:
0D 0A 24 B1 64 33 C0 BA-03 05 BB 00 01 40 50 FE
CE 75 0C 83 EB 04 66 C7-07 42 75 7A 7A B6 05 FE
CA 75 0C 83 EB 04 66 C7-07 46 69 7A 7A B2 03 84
FF 74 0C D4 0A 04 30 4B-88 07 C1 E8 08 75 F4 52
8B D3 B4 09 CD 21 5A 58-E2 C0 C3

Source code (TASM syntax):
    .MODEL TINY

    .CODE
    .386
    org 100h

MAIN PROC
    db 13, 10, '$'
    mov cl, 100
    xor ax, ax
    mov dx, 503h

main_loop:
    mov bx, 100h
    inc ax
    push ax

    dec dh
    jnz short buzz_done
    sub bx, 4
    mov dword ptr [bx], 'zzuB'
    mov dh, 5
buzz_done:

    dec dl
    jnz short fizz_done
    sub bx, 4
    mov dword ptr [bx], 'zziF'
    mov dl, 3
fizz_done:

    test bh, bh
    jz short num_done

decimal_loop:
    aam;
    add al, '0'
    dec bx
    mov [bx], al
    shr ax, 8
    jnz decimal_loop

num_done:
    push dx
    mov dx, bx;
    mov ah, 9
    int 21h
    pop dx
    pop ax

    loop main_loop
    ret

MAIN ENDP
    END MAIN

This code counts from 1 to 100 in ax, building the output message from the end to the beginning. The end of the message (newline and the $ character that DOS uses for end-of-message flag) appears at the beginning of the code:
db 10, 10, '$'

It's executed as a harmless instruction (or ax, 240ah). I could put it in a more conventional place, like after the end of the code, but having it at address 0x100 has a benefit.
The code also uses 2 additional counters:

Counting from 3 to 0 in dl
Counting from 5 to 0 in dh

When a counter reaches 0, it pushes the string Fizz or Buzz to the end of the output message. If this happens, bx will be decreased, and bh will be zero. This is used as a condition for outputting the number in a decimal form.
Note: I am using 32-bit data here. This won't work on a pre-386 computer.

Does TASM really handle multi-byte characters constants in the opposite order from NASM?  In NASM, you write mov [mem], 'Fizz' to store Fizz in that order in memory, matching db directives.  See my overcomplicated "efficient" YASM FizzBuzz for example.

Does it save any bytes to use std, then stosb / stosd?  You'd have to replace test bh,bh with cmp di, 100h or something.  Instead of saving/restoring the counter in AL, you could keep it in BL and just clobber eax whenever you want.  E.g. sub bx, 4
/ mov dword ptr [bx], 'zzuB' is 3+7 bytes, right?  mov eax, 'zzuB' / stosd is 6+2 bytes (operand-size prefix on both).  It would be nice if the answer included disassembly so instruction sizes were visible.

This is a great answer - abusing benign instructions for data and using never-used PSP memory space. @PeterCordes I played with your suggestions using stosd but wasn't able to eek out any score reduction myself. Since stosd decrements DI afterwards you don't get to lose the sub di, 4 and then you have DI 4 bytes off at the end.  I was able to -6 bytes using a few other minor tweaks which I ended up posting as a separate answer (only because I couldn't possibly fit in all a comment). Kudos!

JavaScript, 65 bytes
for(i=0;i++<100;console.log((i%3?'':'Fizz')+(i%5?'':'Buzz')||i));

The shortest approach I've found yet. Perhaps there's a better one; suggestions are welcome. This was originally flagged ES6, but this works in ES5, and to my knowledge there's not a shorter way with ES6 features.
Here's another attempt, using .slice and some complicated maths for a total of 66 bytes:
for(i=0;i++<100;console.log('FizzBuzz'.slice(i%3&&4,i%5?4:8)||i));

(Thanks to Ben Fortune for a couple of handy tricks!)

You could shorten your second attempt to for(i=0;i++<100;console.log('FizzBuzz'.slice(i%3&&4,i%5?4:8)||i));

If you move console.log(...) outside for(...;...;...), you can drop the semicolon.

This is old, but ES6 plus Dennis= 61 bytes:
     for(i=0;i++<100;)console.log(i%3?i:'fizz'+`${i%5?'':'Buzz'}`) I can't make it a code block because the template string won't show up correctly

@GenericUser That doesn't quite work; it never prints Buzz by itself. To insert code with backticks in it, just use 2 or 3 backticks on each end.

dc, 64 62 bytes
[[Fizz]P]sI[[Buzz]P]sU[dn]sNz[zdd3%d0=Ir5%d0=U*0<NAPz9B>L]dsLx

Ungolfed:
[[Fizz]P]sI  # macro I: print "Fizz"
[[Buzz]P]sU  # macro U: print "Buzz"
[dn]sN       # macro N: print current stack depth

z            # increase stack depth

[            # Begin macro
  zdd           # Get current stack depth and ducplicate it twice
  3%d0=I        # Check modulo 3 and leave a duplicate. If it's 0, run macro I
  r             # Rotate top two elements, bringing up the stack depth again
  5%d0=U        # Check modulo 5 and leave a duplicate. It it's 0, run macro U
  *             # Multiply the duplicates of modulos of 3 and 5 ...
  0<N           # ... if it's not 0, run macro N
  AP            # Print a newline (`A` is 10)
                # The macro leaves the stack with one more element each time
  z9B>L      # Run macro L if stack depth is less than "ninety eleven" (101)
]         # End macro

dsLx  # store the macro in register L and execute it

Lua, 72 bytes
for i=1,100 do print(({'FizzBuzz','Buzz','Fizz',i})[i^2%3+i^4%5*2+1])end

Tied the world record! (Please don't cheat the rankings there.)

I stole this technique for my AppleScript answer.

Cool answer. My 72 was for x=1,100 do print(({x,[0]="FizzBuzz",[6]="Fizz"})[x^4%15]or"Buzz")end, but looking at yours, I saw this 70: for x=1,100 do print(({"FizzBuzz",x,[7]="Fizz"})[1+x^4%15]or"Buzz")end

@tehtmi Oh, that’s so nifty!

67 bytes... https://code.golf/rankings/holes/fizz-buzz/lua/bytes

80386 machine code + DOS, 75 68 bytes
NOTE: This is a reply to @anatolyg's really clever 2015 answer, with a few tweaks to reduce the score by 7 bytes. I'm only submitting this as a separate answer because it wouldn't be possible to explain fully in a comment.
Changes:

Use SI to reset BX since DOS sets SI initially to 100H (ref) instead of an imm. (-1 byte)
Instead of using a 3/5 counter in DH/DL, use AAM for modulo operations on counter.  AAM is a 2 byte instruction that's effectively a byte-length DIV that can accept an imm value as the divisor and also sets ZF if AL mod n = 0. @Peter Cordes touches on this in his very brilliant post about FizzBuzz in assembly. (-5 bytes)
Instead of CR/LF, use LF/CR (the order doesn't matter to DOS). This translates to an instruction that does not modify the startup value of AX (in fact it zeroes out AL) so we can eliminate the xor ax,ax and save two bytes. It does come at a cost because 0A 0D is only a two-byte instruction so the rest of the 24xx instruction needs to be padded with one more byte. (-1 byte)

Unassembled:
0A 0D           or cl, [di]             ; LF and CR bytes (newline)
24 00           and al, 0               ; DOS string delim ('$') + pad byte
B1 64           mov cl, 100             ; set loop counter to 100

            main_loop:
8B DE           mov bx, si              ; init bx to 100h
40              inc ax                  ; increment fizzbuzz counter
50              push ax                 ; save fizzbuzz counter

50              push ax                 ; save ax from getting clobbered by AAM
D4 05           aam 5                   ; AL = AL mod 5, ZF if AL = 0
58              pop ax                  ; restore ax
75 0A           jnz short buzz_done     ; jump if not a 'Fizz'
83 EB 04        sub bx, 4               ; offset for output string
66C707 7A7A7542 mov dword ptr [bx], 'zzuB'
            buzz_done:

50              push ax
D4 03           aam 3                   ; AL = AL mod 3, ZF if AL = 0
58              pop ax
75 0A           jnz short fizz_done     ; jump if not a 'Buzz'
83 EB 04        sub bx, 4
66C707 7A7A6946 mov dword ptr [bx], 'zziF'

            fizz_done:

84 FF           test bh, bh             ; either a Fizz or a Buzz? (BX not changed)
74 0C           jz short num_done       ; if so, do not display a digit

            decimal_loop:
D4 0A           aam;                    ; AL = AL mod 10
04 30           add al, '0'             ; convert to ASCII
4B              dec bx
88 07           mov [bx], al
C1 E8 08        shr ax, 8               ; 'mov al, ah', ZF if AL = 0
75 F4           jnz decimal_loop

            num_done:
8B D3           mov dx, bx              ; set dx to output string pointer
B4 09           mov ah, 9
CD 21           int 21h
58              pop ax                  ; restore fizzbuzz counter

E2 C3           loop main_loop
C3              ret

xxd binary:
00000000: 0a0d 2400 b164 8bde 4050 50d4 0558 750a  ..$..d..@PP..Xu.
00000010: 83eb 0466 c707 4275 7a7a 50d4 0358 750a  ...f..BuzzP..Xu.
00000020: 83eb 0466 c707 4669 7a7a 84ff 740c d40a  ...f..Fizz..t...
00000030: 0430 4b88 07c1 e808 75f4 8bd3 b409 cd21  .0K.....u......!
00000040: 58e2 c3c3                                X...

Of course it's a competing answer! It has nice ideas. Competition of this kind is exactly what this site needs!

Bash, 58 bytes
eval i={1..100}';a=([i%3]=Fizz [i%5]+=Buzz);echo ${a-$i};'

Try it online!

7 people have copied this solution verbatim, but only 3 upvotes? Have another.

Not assigning i saves one: eval {0..99}';a=([++i%3]=Fizz [i%5]+=Buzz);echo ${a-$i};'

Julia, 64 bytes
for i=1:100 x="Fizz"^(i%3<1)*"Buzz"^(i%5<1);println(x>""?x:i)end

Bubblegum, 131 129 bytes
0000000: 4d cd bb 0d c4 30 0c 03 d0 9e db e8 63 7d da 14 d9 e5  M....0......c}....
0000012: 06 b8 26 d3 e7 60 0b 38 56 a6 29 10 4f a0 b8 3f cf 03  ..&..`.8V.).O..?..
0000024: c7 f5 fd 3d 3b 27 ea 84 5d 89 9c 8f 18 c4 77 3c 75 40  ...=;'..].....w fizzbuzz.bg.
Compression has been done with Python's zlib, which uses the DEFLATE format but obtains a better ratio than (g)zip.
Thanks to @Sp3000 for -2 bytes!

You could golf off about 43 bytes by breaking SHA-256.

@ThomasKwa: sounds easy.

Python 2, 61 60 bytes
for i in range(1,101):print"Fizz"*(i%3<1)+"Buzz"*(i%5<1)or i

This is invalid: it prints 0 at the start

You could use either i+1 or range(1,101) to fix it.

Now it only goes up to 99.

I already have 56 FYI.

the output is also straight up incorrect.  89 prints out a FizzBuzz whereas 90 is printed as 90

Have you actually tested this program?

To whoever downvoted, the program works as it is now.

Common Lisp, 123 116
(dotimes(i 100)(loop for(m s)in'((3"Fizz")(5"Buzz"))if(=(mod(1+ i)m)0)do(princ s))(do()((fresh-line))(princ(1+ i))))

Pretty-printed
(dotimes (i 100)
  (loop for (m s) in '((3 "Fizz") (5 "Buzz"))
        if (= (mod (1+ i) m) 0)
        do (princ s))
  (do () ((fresh-line)) (princ (1+ i))))

The do/fresh-line trick
The inner loop iterates over ((3 "Fizz") (5 "Buzz")) for each i and, according to the result of the two consecutive mod operations, eventually prints:

nothing
or Fizz
or Buzz
or FizzBuzz

fresh-line is a nice little function that as far as I know is only found in Common Lisp. It adds a newline only if necessary, and returns T only when the newline was added. For the above situations, according to whether we printed something or not, the return values of (fresh-line) are thus respectively:

NIL
T
T
T

So I know that the integer must be printed only when we did not print a fresh-line. But if I print the integer, I must also print a newline after it. That's why there is a DO.
DO is a basic yet looping construct that iterates until a condition is met. Here, the condition is the return value of (fresh-line). It it tested before each iteration of the body of the loop, notably the first one. So if the test returns T, then we exit the DO. Otherwise, we execute the body, which prints the integer. Then, we execute the test once again and this time, it returns T because current line is "dirty" (there is an integer printed now).

Clever! I don't think I can change my CL answer to beat it.

@nanny If that can comfort you, I don't think I can either. I saw your answer, it was hard to beat.

Great answer. I learnt some from it and don't understand it fully yet. However I think I've managed to beat you by 13 bytes using different method.

TrumpScript, 938 bytes
As always nothing is, 1000001 minus 1000000;
And Putin is, 1000003 minus 1000000; great
Just as Trump is, 1000005 minus 1000000; even better
Also as America is, Putin times Trump; the best
Most importantly Ivanka is, 1000101 minus 1000000;
And believe me that Hillary is nothing
As long as, Hillary thinks less of Ivanka;:
China is friends with Hillary
Democrats are idiots like Hillary
Obama is in line with Hillary
As long as, China thinks its more than America;:
Make China, China minus America;!
As long as, Democrats fear more Trump;:
Make Democrats, Democrats minus Trump;!
As long as, Obama gets more arsenal against Putin;:
Make Obama, Obama minus Putin;!
If everybody thinks, America is China?;:
Say "FizzBuzz"!
Otherwise: if we ask, Democrats are Trump?;:
Say "Buzz"!
Otherwise: what if, Obama is Putin?;:
Say "Fizz"!
Otherwise do this: tell Hillary all her lies!!!
Hillary is, as always Hillary plus nothing;!
America is great.

Try it online!
I was quite bored... Not too efficient, but fun!
Pseudocode:
var nothing = 1, Putin = 3, Trump = 5, America = Putin * Trump, Ivanka = 101, Hillary = nothing;
while Hillary < Ivanka
    var China = Democrats = Obama = Hillary;
    while China > America
        China = China - America;
    while Democrats > Trump
        Democrats = Democrats - Trump;
    while Obama > Putin
        Obama = Obama - Putin;
    if China == America
        print "FizzBuzz";
    else if Democrats == Trump
        print "Buzz";
    else if Obama == Putin
        print "Fizz";
    else
        print Hillary;
    Hillary = Hillary + nothing;
America is great.

R, 68 66 bytes
for(i in 1:100)write(max(i,paste0("Fizz"[!i%%3],"Buzz"[!i%%5])),1)

I must be missing something here because this is way too simple. I know that you really shouldn't use loops in R but like this is a bit smaller than the first R one I saw so yeah.
Edited about a day after the original: you can get rid of the curly braces to save 2 characters.

Welcome to Code Golf StackExchange, nice first answer. (It's also the winning R answer here!)

@Third-party'Chef' Damn, it's incredible that it took five years for the shortest R solution to be found

Eh, don't count it as the shortest ever. Some crazy guy will find some way to make something smaller haha

Japt, 45 44 43 39 36 35 33 32 31 bytes
Japt is a shortened version of JavaScript.
Lò1@"Fizz"pXv3)+"Buzz"pXv5)ªXÃ·

Try it online!
How it works
Lò1@"Fizz"pXv3)+"Buzz"pXv5)ª XÃ ·
Lò1@"Fizz"pXv3)+"Buzz"pXv5)||X} qR

Lò1       // Create the inclusive array [1...100].
@         // Map each item X in this range to:
 "Fizz"p  //  "Fizz" repeated:
  Xv3)    //   if X is divisible by 3, 1 time, otherwise, 0 times;
 +        //  concatenated with
 "Buzz"p  //  "Buzz" repeated:
  Xv5)    //   if X is divisible by 5, 1 time, otherwise, 0 times.
 ||X      //  If the result is an empty string, set it to X.
} qR      // Join the range with newlines.
          // Implicit: output last expression

Old version, 32 bytes:
Lo@"FizzBuzz"s°X%3©4X%5?4:8 ªXÃ·
Lo@"FizzBuzz"s++X%3&&4X%5?4:8 ||X} qR

Lo            // Create the range [0..100).
@             // Map each item X in this array to:
 "FizzBuzz"s  //  "FizzBuzz".slice(
  ++X%3&&4    //   if ++X is divisible by 3, 0; else, 4,
  X%5?4:8     //   if X is divisible by 5, 8; else, 4).
 ||X          //  If the result is an empty string, set it to X.
} qR          // Join the range with newlines.
              // Implicit: output last expression

Alternate version (45 44 40 38 bytes): (Note: this doesn't work in the current version of Japt)
1o#e £(X%3?":Fizz" +(X%5?":Buzz" ªX} ·
1o#e m@(X%3?":Fizz" +(X%5?":Buzz" ||X} qR

1o#e          // Create an array of 1 to 100.
m@            // Map each item X in this array to:
 (X%3?":Fizz" //  If X is divisible by 3, "Fizz"; else, an empty string
 +            //  concatenated to:
 (X%5?":Buzz" //  if X is divisible by 5, "Buzz"; else, an empty string.
 ||X          //  If the result is an empty string, set it to X.
} qR          // Join the range with newlines.
              // Implicit: output last expression

Suggestions welcome!

Bash, 85 81 78 74 72 71 bytes
for((;i++<100;j=i%3&2|i%5/4)){
o=($i Buzz Fizz FizzBuzz)
echo ${o[j]}
}

Thanks to @Neil for saving 4 bytes!
Thanks to @manatwork for saving 3 bytes!
Thanks to @primo for saving 2 bytes!
Try it online!

for i in {1..100}\n{ → for((;100>i++;)){

Bash + coreutils, 41 bytes
seq 100|sed 5~5cBuzz|sed 3~3s/[^B]*/Fizz/

You can't seem to do better without cheating: the 12-byte answers on that server simply invoke its gs2 interpreter with a 1-byte FizzBuzz program...

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

Try it online!
Explanation
Cell indexes in comments are in hexadecimal to match numbering in bfdev debug view.
# #####################
# ##### VARIABLES #####
# #####################

# C1 & C2: 48 (ascii 0)
-[>+>+<<-----]>--->-->
# C3: 10 (ascii LF)
++++++++++>
# C4: Singles counter
->
# C5: Tens counter
++++++++++>
# C6: is1to9 if countdown
+++++++++>
# C7: 0 to enter/exit is1to9, or 1 to enter is10to99
>
# C8: 0 to not enter is10to99
>
# C9: isMultiOf3 if countdown
+++>
# CA: 0 to exit isMultiOf3, or 1 to enter !isMultiOf3
>
# CB: 0 to not enter !isMultiOf3
>
# CC: isMultiOf5 if countdown
+++++>
# CD: 0 to exit isMultiOf5, or 1 to enter !isMultiOf5
>
# CE: 0 to not enter !isMultiOf5
>
# CF: 70 F, and put C13 to 70
>>-[<+<+>>-------]<---<--->
# C10: 66 - ascii B
---->
# C11: 105 - ascii i
>-[<++>-----]<+++>
# C12: 122 - ascii z, and put C16 to 122
>>----[<+++<+++>>--]<
# C13: 117 - ascii u
-----
# Goto C5
<<<<<<<<<<<<<<

# #################
# ##### LOGIC #####
# #################

# While C5 (tens counter): Print 1-99
[
# Restore C4: singles counter
  <++++++++++
# For 0 to 9, using singles counter
  [
#   Goto C6
    >>
#   If is1to9
    [
#     Decrement is1to9 countdown
      -
#     Prepare else condition at C8
      >>-<
    ]
#   Goto C7 or C8
    >+
#   Else If C7: is10to99
    [
#     Decrement C7
      -
#     Goto CC
      >>>>>-
#     If is not multi of 5
      [
#       Goto C9
        <<<-
#       If is not multi of 3
        [
#         Print C1: tens
          <<<<<<<<.
#         Prepare else condition at CB
          >>>>>>>>>>-
#         Goto CA
          <
        ]
#       Goto CA or CB
        >+
#       Else If is multi of 3
        [
#         Goto CA, restore, goto CB
          ->
        ]
#       Goto C9 and restore
        <<+
#       Prepare else condition at C1E
        >>>>>-
#       Goto C1D
        <
      ]
#     Goto CD or CE
      >+
#     Else If is multi of 5
      [
#       Goto CD, restore, goto CE
        ->
      ]
#     Goto CC and restore
      <<+
#     Goto C8
      <<<<
    ]
#   Goto C9
    >-
#   If is not multi of 3
    [
#     Goto CC
      >>>-
#     If is not multi of 5
      [
#       Print C2: singles
        <<<<<<<<<<.
#       Prepare else condition at CE
        >>>>>>>>>>>>-
#       Goto CD
        <
      ]
#     Goto CD or CE
      >+
#     Else If is multi of 5
      [
#       Goto CD, restore, goto CE
        ->
      ]
#     Goto CC and restore
      <<+
#     Prepare else condition at CB
      <-
#     Goto CA
      <
    ]
#   Goto CA or CB
    >+
#   Else If is multi of 3
    [
#     Print Fizz
      >>>>>.>>.>..
#     Goto C9 (If is not multi of 3)
      <<<<<<<<<
#     Restore C9
      +++
#     Goto CA, decrease, goto CB
      >->
    ]
#   Goto CC
    >-
#   If is not multi of 5
    [
#     Prepare else condition at CE
      >>-
#     Goto CD
      <
    ]
#   Goto CD or CE
    >+
#   Else If is multi of 5
    [
#     Goto C10 and print Buzz
      >>>.>>>.<..
#     Goto CC (If is not multi of 5) and restore
      <<<<<<+++++
#     Goto CD, decrease, goto CE
      >->
    ]
#   Goto C2: singles, and increment
    <<<<<<<<<<<<+
#   Print C3: LF
    >.
#   Decrement C4: singles counter
    >-
  ]
# Restore C2: singles ascii
  <<----------
# Increment C1: tens ascii
  <+
# Goto C5 (tens counter) and decrement it
  >>>>-
]
# Goto C10 and print Buzz
>>>>>>>>>>>.>>>.<..

HTML & CSS, 502 485 bytes

body{counter-reset:n}
p::after{counter-increment:n;content:counter(n)}
p:nth-child(3n)::before{content:"Fizz"}
p:nth-child(3n)::after{content:""}
p:nth-child(5n)::after{content:"Buzz"}

Nice answer! You don't need the
 elements and you can skip the closing
 tags as well, it should still render fine.

Thanks @emanresuA. I still needed an element to apply the counter-reset to but it could just have been the body. Removing the closing
 helped shave off a lots of bytes.

Mathematica, 83 75 73 67 62 bytes
Print/@(#/.(##&[15#->FizzBuzz,3#->Fizz,5#->Buzz]&)/@#&@Range@100)

I do not think that this could be golfed any further. Thanks to branislav for helping me golf this.

golf it down to 66 bytes by first removing all quotation marks, second using ...\\Column instead of Print/@(...)

then how about Print/@%

@branislav It doesn't end up saving any bytes.

62 bytes: Print/@(#/.(##&[15#->FizzBuzz,3#->Fizz,5#->Buzz]&)/@#&@Range@100), a one-liner without exotic characters, you asked for it ;D I think now we're at the end

You mean Mathematica doesn't have a FizzBuzz builtin?

You can save 1 byte with Echo

@shrx Echo adds a leading >> to the output.

This is a fantastic answer, but unfortunately I don't think it is valid in Mathematica 11 as it yields {Null, Null, Null.....Null} after the output. Is it saveable? Otherwise, I have Row@Pick[{Fizz,Buzz},#~Mod~{3,5},0]/.{}->{#}&~Array~100//Column which comes in at two bytes longer.

I should make it clear that I don't think that not working in the up-to-date version in any way invalidates this answer! But I'm interested to know what the best solution is in 11.

Heavily inspired by a discussion on Mathematica SE, this comes in at 61 fizzbuzz[#,,fizz,,buzz][[#~GCD~15~Mod~15]]&~Array~100//Column

@ASimmons The list of Nulls doesn't get output to STDOUT, and neither does the actual output on your proposed solution.

C++, 130 126 119 115
#include<iostream>
int i;int main(){for(auto&o=std::cout;++i<101;o<<'\n')i%3?o:o<<"Fizz",i%5?i%3?o<<i:o:o<<"Buzz";}

Live version.

Suggest i%3||o<<"Fizz"

MoonScript, 83 82 bytes
[print(i%15==0and"FizzBuzz"or(i%3==0and"Fizz")or(i%5==0and"Buzz")or i) for i=1,100]

Welcome to Programming Puzzles & Code Golf!

Rotor, 32 31 bytes
1N2{3%!"Fizz"~5%!"Buzz"N$?~N}\

This has one unprintable, so here's a hexdump:
0000000: 314e 7f32 7b33 2521 2246 697a 7a22 7e35  1N.2{3%!"Fizz"~5
0000010: 2521 2242 757a 7a22 4e24 3f7e 4e7d 5c    %!"Buzz"N$?~N}\

Explanation:
1  Push a one to the stack.
N  Push a newline.
^? Spooky invisible unprintable that pushes 100 to the stack.
2  Pushes a two to the stack.
{  Starts block.
  3%      Takes mod 3 of the top number on the stack.
  !"Fizz" If falsy, push "Fizz".
  ~       Push the contents of the register.
  5%      Takes mod 5.
  !"Buzz" If falsy, push "Buzz".
  N$      Compares the top value of the stack to a newline. (this doesn't pop the values off the stack)
  ?~      If truthy, push the contents of the register.
  N       Push a newline.
}\ For loop between 2 and 100, pushing the counter to the register and stack each time.

Try it online. (note that it is very slow)
Check out Rotor.

Brainfuck, 16321 3602 1597
Almost as short as Java. This is just the trivial answer generated by another program, This is still a computer generated answer, but I am sure there are way shorter solutions! The general idea is initializing the cells to 4 B F i u z. If the program has to output a number, it just goes to the first cell and manipualtes it, if it is one of the letters, it will just jump to the corresponding cell and output it.
++++++++++<<+++++++[>+++++++<-]>[>>+>+>+>++>++>++<<<<<<<-]>>+++>+++++++++++++++++>+++++++++++++++++++++>+++++++>+++++++++++++++++++>++++++++++++++++++++++++<<<<<---.<.>+.<.>>>.>.>>..<<<<<<.>++.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>+++.<.>+.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.>-------..<.>>>.>.>>..<<<<<<.>.++.<.>--.+++.<.>>>.>.>>..<<<<.>>>.>..<<<<<<.>---.+++++.<.>-----.++++++.<.>>>.>.>>..<<<<<<.>------.++++++++.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>-------..<.>.+.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.>-.++++.<.>>>.>.>>..<<<<<<.>----.++++++.<.>------.+++++++.<.>>>.>.>>..<<<<.>>>.>..<<<<<<.>------.--.<.>++.-.<.>>>.>.>>..<<<<<<.>+.+.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>-.++++.<.>----.+++++.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.>----.---.<.>>>.>.>>..<<<<<<.>+++.-.<.>+..<.>>>.>.>>..<<<<.>>>.>..<<<<<<.>.++.<.>--.+++.<.>>>.>.>>..<<<<<<.>---.+++++.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>----.---.<.>+++.--.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.>++.+.<.>>>.>.>>..<<<<<<.>-.+++.<.>---.++++.<.>>>.>.>>..<<<<.>>>.>..<<<<<<.>---.-----.<.>+++++.----.<.>>>.>.>>..<<<<<<.>++++.--.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>++.+.<.>-.++.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.>-.------.<.>>>.>.>>..<<<<<<.>++++++.----.<.>++++.---.<.>>>.>.>>..<<<<.>>>.>..<<<<<<.>+++.-.<.>+..<.>>>.>.>>..<<<<<<.>.++.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>-.------.<.>++++++.-----.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.>+++++.--.<.>>>.>.>>..<<<<<<.>++..<.>.+.<.>>>.>.>>..<<<<.>>>.>..<<<<<<.>.--------.<.>++++++++.-------.<.>>>.>.>>..<<<<<<.>+++++++.-----.<.>>.>>>.>..<<<<<<.>>>.>.>>..<<<<<<.>+++++.--.<.>++.-.<.>>>.>.>>..<<<<<<.>>.>>>.>..<<<<<<.

Nice solution! I could get to 425 bytes by manually writing the brainfuck code.

Common Lisp, 103 101 96 93 84 bytes
(dotimes(i 101)(format t"~v^~[Fizz~[Buzz~]~:;~[Buzz~:;~a~]~]
"i(mod i 3)(mod i 5)i))

Try it online!
It's shorter than other CL solution and it uses different method. Conditions are handled inside format function.
-5 bytes - shorter version of handling i=0
-3 bytes - ~^ with only one parameter seems to work as if second parameter was 0, which is saves 2 bytes. Last byte is saved by substituting ~% by <enter>
-9 bytes - by ASCII-only

You can use ~[ instead of ~:[ and remove the (= ... 0) to reduce it to 84 bytes (with a bit of rearrangement). (not posting link because it would spoiler current code-golf.io best)

@ASCII-only Thank you for suggestion but it seems unobvious, how to do it. Without (=(mod i 5)0) I seem to need to handle residues of 1,2,3,4 separately (and similiarily for (=(mod i 3)0): 1 and 2).

No... just use ~:; to add a default fallback: (dotimes(i 101)(format t"~v^~[Fizz~[Buzz~]~:;~[Buzz~:;~a~]~]<newline>"i(mod i 3)(mod i 5)i)) where <newline> is replaced with literal newline

05AB1E, 29 bytes
тLʒ"Fizz"D'ÒÖ™DŠ«)¬ÑD5ås3å«è,

Try it online!
To my surprise (or my incapability to use the search function) there was no 05AB1E answer to this question.
Explanation
тLʒ"Fizz"D'ÒÖ™DŠ«)¬ÑD5ås3å«è,
тL                            # push [1,...,100]
  ʒ                           # for each...
   "Fizz"                      # Push Fizz (didn't find a way to shorten this one sadly)
         D                     # Duplicate
          'ÒÖ™                 # Push Buzz
              D                # Duplicate
               Š               # Move top item on the stack two slots down
                «              # Concatenate the top items (Results in FizzBuzz)
                 )             # Wrap stack to array
                  ¬Ñ           # Get Divisors of N
                    D5å        # Does 5 divide it?
                       s3å     # Does 3 divide it?
                          «    # Concatenate top two items
                           è,  # Gets item in the array at the index of the concatenated divisors (indexing wraps around) and prints

Hexagony, 77 76 bytes
=?3})"F\>%'5?\"\B;u;"}/4;d'%<>\g/"!{{\}.%<@>'...<>,}/${;;z;i;z;;$/<>?{$/"./_

Try it online!
Same side length as M L's solution, but a bit smaller.
Expanded:
      = ? 3 } ) "
     . \ > % ' 5 ?
    \ F \ B ; u ; "
   } " / ; d ' % < >
  \ g 4 / ! { { \ } .
 % < @ . > " ' . < > ,
  } / $ { ; ; z ; i ;
   z ; ; $ / < > ? {
    $ / " . / _ . .
     . . . . . . .
      . . . . . .

Coloured 77 byte version (only difference is the bottom right corner):

Green: The general outline of the loop
Light Blue: "Fizz" printer
Dark Blue: "Buzz" printer
Yellow: Number printer
Red: Terminator path

How it Works:
Memory Model:

Num: The counter
Mod: The number we are moduloing(?) with the counter
Temp: Our calculation edge
Check: The FizzBuzz check

Below I'll be referring to the instructions as they are executed, ignoring no-ops and direction changes.
At the start we execute =?3})"%< which increments the counter (initially 0) and checks whether it is divisible by 3. If so, we branch up and execute "F;i;z;;{ which prints "Fizz" in the check edge and returns to the temp edge.
}?5'%>: Now we check if the number is divisible by 5. If so, B;u;"z;; prints "Buzz" in the check edge (the " is out of place to prevent printing an excess character at termination). If not, we execute an extra instruction to switch to the check edge.
If Fizz and/or Buzz has been printed, the check edge has a leftover "z" in it, else it is 0. If it is a 0, we execute z{{!"'} which puts a z in the check edge and prints the number before returning to the check edge and executing the check again. Now the check edge has a "z" in it no matter what, so we branch to the ?{}g4; which prints a newline.
Finally, d'% checks if the number is divisible by 100. If so, it terminates. Otherwise, it moves to the start of the loop.

BuzzFizz, 86 bytes
$a++
if3\$a:print"Fizz"
if5\$a:print"Buzz"
else:print$a
print"\n"
if100\$a:#
else:loop

Try it online!
Explanation
Despite being golfed, all you have to do is to add a bit of horizontal whitespace and a few comments to get possibly one of the clearest and most readable FizzBuzzes ever. (Vertical whitespace is significant in BuzzFizz, apart from (by popular demand) the trailing newline, so it's necessary even in a golfed program.)
# Counters start at 0. So $a will be increased to 1 on the first iteration.
# On subsequent iterations, it counts up by 1 each time.
$a++

# BuzzFizz supports only one operator: \, the "divides into" relational
# operator. So you'll be seeing that every time there's an if statement.
# It's pretty helpful for a fizzbuzz!
if 3\$a: print "Fizz"
if 5\$a: print "Buzz"

# The "else" statement attaches to *both* "if" statements simultaneously;
# it'll only run if neither of them did. "else" always attaches to all
# "if" statements since the preceding "else", so sometimes a dummy "else"
# statement is needed in order to clear the state. We don't need to
# resort to that for our FizzBuzz program, though.
else: print $a

# Now we've printed Fizz/Buzz/FizzBuzz/the number, print a newline.
print "\n"

# Our loop ends when $a becomes 100. 100 is the lowest positive integer
# that's divisible by 100, so we can use a divisibility test to find
# the end of the loop. We negate the test via the use of a comment as
# the body of the "if" statement (an "if" body cannot be empty in
# BuzzFizz, but a comment counts as a statement).
if 100\$a: # do nothing

# If $a is *not* divisible by 100, we have another iteration. So loop
# back to the start of the program.
else: loop

Discussion
In addition to the commands seen in the FizzBuzz program above, BuzzFizz also supports input (if you use an identifier like a with no leading $, the program will ask for its value; you can use a statement like clear a to reset the value so that the program asks for it again the next time it's used). Other than that, the above program shows off all the features of the language; in other words, we have a complete language built entirely out of the operations you need to write a simple FizzBuzz program (thus the name).
Despite its inspiration, BuzzFizz is not specialised merely for FizzBuzzes; you can take the FizzBuzz program apart, put it together in other ways, and solve a surprisingly large range of problems. For example, the Esolang page for the language has a primality tester and a program which adds two positive numbers. (The primality tester is simpler than the addition program; given BuzzFizz's choice of operator, this probably shouldn't be too surprising.)
That said, the language is (intentionally) not Turing-complete; the original inspiration of the language was to act as a counterexample to people who made claims of the form "any language that can do X must be Turing-complete", as the most common choices of X don't actually require it. On the other hand, it's also (intentionally) very powerful for a sub-Turing language; it's fairly hard to come up with simple problems that BuzzFizz can't solve and Turing-complete languages can.

J, 45 bytes
New Version, thanks to Bolce Bussiere:
(,&((;,>)Fizz`Buzz)@":{~+.&3-~0:<5&|)"0>:i.100

Old version (52 bytes):
(,&('Fizz'(,>@;;)'Buzz')@":{~+.&3-~0:~:5&|)"0>:i.100

Explanation
Best explained by breaking it up into smaller verbs. Overall the main working portion is a train:
getlist {~ getindex

where getlist i returns a 4-length list of the default format of i, 'FizzBuzz', 'Fizz', and 'Buzz'; and getindex i returns -1 if i is divisible by 5 only, -2 if divisible by 3 only, 1 if divisible by both, and 0 otherwise. The verb {~ grabs the right argumentth element from its left argument, the list created by getlist, where the index is modulo'd by the length of the list, meaning -1 will grab the last element, -2 the second-to-last, etc.
In
getlist=:,&('Fizz'(,>@;;)'Buzz')@":

": gets the default format of i, and then ,&('Fizz'(,>@;;)'Buzz') appends it to the beginning of the list created using the train ,>@;; on the two arguments 'Fizz' and 'Buzz' (append them and raze them, then raze those results together and unbox each item), in the new version ((;,>)Fizz`Buzz) does essentially the same thing but takes advantage of the ` that boxes, then appends the two strings before applying the train ;,> on the resulting list of boxes (unbox each element; raze the elements together to get FizzBuzz; append the unboxed elements with FizzBuzz)
In
getindex=:+.&3-~0:~:5&|

+.&3 gets the GCD of i and 3, and 5&| returns i modulo 5. The train 0:~:5&| returns 1 if 5&| is unequal (~:, or in the new version < because the result of 5&| will always be greater than or equal to 0) to the result of the constant function 0: (which returns 0 for any argument) and 0 otherwise, then getindex is a train that, from this value, subtracts +.&3 resulting in the return values given above.
The boring parts are the "0 which simply tells the verb to operate on atoms of any argument given to it, and >:i.100, which returns a list of integers from 1 to 100 (inclusive).

Using < instead of ~: saves a byte

And (;,>)Fizz\Buzzinstead of'Fizz'(,>@;;)'Buzz'` saves another 5

@BolceBussiere < instead of :~:?

@ASCII-only the first : belongs to the verb 0: that returns the constant 0. The verb ~: represents 'not equal'

Idk, using just constant 0 worked for me

Didn't work for me. It works with an echo, though. echo(,&((;,>)Fizz\Buzz)@":{~+.&3-~0:<5&|)"0>:i.100`

Whispers v2, 150 bytes
> 100
>> (1]
> "Fizz"
> "Buzz"
>> 3+4
> 0
>> Then 5 6 6 3 6 4 3 6 6 3 4 6 3 6 6
>> 7ⁿR
>> Each 8 2
>> L∨R
>> Each 10 9 2
>> Output L
>> Each 12 11

Try it online!
Maybe it could be improved, but programming in Whispers is driving me crazy. I'm starting to hear voices...whispering...in my head
Explanation
In Whispers, numbers in lines beginning with >>  refer to line numbers. Here is what each line is computing:
> 100                                   1:100
>> (1]                                  2:[1,2,...,100]
> "Fizz"                                3:"Fizz"
> "Buzz"                                4:"Buzz"
>> 3+4                                  5:"FizzBuzz"
> 0                                     6:0
>> Then 5 6 6 3 6 4 3 6 6 3 4 6 3 6 6   7:["FizzBuzz",0,0,"Fizz",0,"Buzz","Fizz"...]
                                         (FizzBuzz without numbers for values 0 to 15)
>> 7ⁿR                                  8:Modular indexing function into the previous array
>> Each 8 2                             9:[0,0,"Fizz",0,"Buzz","Fizz",...]
                                         (FizzBuzz without numbers for values 1 to 100)
>> L∨R                                  10:OR function
>> Each 10 9 2                          11:Zip with OR the arrays in lines 9 and 2
                                         (Complete list of FizzBuzz values)
>> Output L                             12:Print function
>> Each 12 11                           13:Print each value in line 11

Squire, 92 bytes
n=N whilst C>n{t=""n=n+I if!(n%3){t="Fizz"}if!(n%V){t=t+"Buzz"}proclaim((t||arabic(n))+"
")}

Hear ye, hear ye! Unbeknownst to some, Sampersand hath also created Squire, a companion language to ye lowly language Knight. Squire hath many possessions, but alas, it doth not golfeth as well as its brethren. Thou shalt check it out as well, though.
I cannot provideth thee with a demo link yet as the interpreter is a very lengthy incantation.
Ungolfeth:
# Createth a variable known by most as "n",
# He shalt begin his journey as a mere
# peasant with naught but the value zero.
# (Behold! Squire permits thee to write numbers
# in Roman numerals)
n = N
# Loop thine program unto n approacheth 100
whilst C > n {
    # Lo! I spotteth another variable,
    # who goes by the name of "t".
    # It shall start off as a lonely empty string.
    t = ""
    # Increase n's wealth by bestowing upon it the number one
    n = n + I
    # If n divideth evenly into 3...
    if !(n % 3) {
        # Replaceth t with the string "Fizz"
        t = "Fizz"
    }
    # If n also divideth evenly into 5...
    if !(n % V) {
        # Accompany t with the string "Buzz"
        t = t + "Buzz"
    }
    # Proclaim to ye standard output...
    proclaim(
        # Either...
        (
           #  t if it is not a lonely empty string...
           t
           # or n, converteth to ye foreign Arabic
           # number system, used in lands afar.
           || arabic(n)
        )
        # Appendeth upon it a newline to start
        # another journey.
        + "\n"
    )
}

A more favorable program is as follows:
n=N whilst C>n{t=""n=n+I if!(n%III){t="Fizz"}if!(n%V){t=t="Buzz"}proclaim((t||string(n))+"
")}

This program useth Roman numerals, but nay, thine great quest beseecheth that one must outputeth thy program using this unusual number system.

aussie++, 223 190 187 bytes
G'DAY MATE!
I RECKON x IS A WALKABOUT FROM[1TO 100]<YA RECKON x %15<1?<GIMME "FizzBuzz";>WHATABOUT x %5<1?<GIMME "Buzz";>WHATABOUT x %3<1?<GIMME "Fizz";>WHATABOUT ?<GIMME x;>>CHEERS C***!

Fair dinkum, this was hard yakka cause there's no way to golf the whitespace because the parser seems to be strict. I coulda sworn it never worked when I tried to remove whitespace.
-33 thanks to @Bubbler
-3 thanks to @JoKing
Wanna hear what it actually sounds like? Wonder no more: https://youtu.be/ewu1CmjZcmQ

Idea: Aussie++ on Code Review

Just a note that Aussie++ has an online playground so everyone can try out the code easily. (No permalinks though)

Cubestack, 178 162 bytes
M R2 f' M' S S' y S S' y2 M R' M' R E M r M' E2 M r2 M' E' U M R M' D E S R' b' R2 b r U2 r U2 S' E2 S R' B r l r U2 r U2 S' E' L S S' u S S' y2 M R' M' R F2 b y'

Try it Online!
Final cube state:

Another fine addition to the collection of FizzBuzz I've written.
Explained
M R2 f' M' S S' y      # For each item in the range [0, 100)
S S' y2 M R' M' R      #   Push that item + 1 to the stack
E M r M' E2 M r2 M' E' #   Push the list [3, 5] to the stack
U                      #   Calculate [(item + 1) % 3, (item + 1) % 5]
M R M' D               #   and check if each of those results is equal to 0
E ... E2               #   Push the list ["Fizz", "Buzz"] to the stack
L S S' u               #   and multiply the strings with the modulo equality list.
                       #   This implements the ("Fizz" * (item % 3 == 0)) + ("Buzz" * (item % 5 == 0))
                       #   I use in my other fizzbuzzes to concisely do the multiplicity check
S S' y2 M R' M' R      #   Push the item + 1 to the stack again. Needed because there's no DUP yet
F2 b                   #   Logically or that with the FizzBuzz string and print with a newline.
                       #   If the item isn't divisible by 3 or 5, then the fizzbuzz string will be empty
                       #   meaning the logical or here will return the number. Otherwise it'll return whatever word is needed.
y'                     # End the loop

MediaWiki markup + WP templates, 142 bytes
{{for nowiki|
|<nowiki>{{If then show|{{#ifeq:{{mod|{{{1}}}|3}}|0|Fizz|}}{{#ifeq:{{mod|{{{1}}}|5}}|0|Buzz|}}|{{{1}}}}}</nowiki>|count=100}}

Explanation
This will only work on the English Wikipedia.
{{for nowiki
|

|<nowiki>{{If then show|
{{#ifeq:{{mod|{{{1}}}|3}}|0|Fizz|}}{{#ifeq:{{mod|{{{1}}}|5}}|0|Buzz|}}|{{{1}}}}}</nowiki>
|count=100}}

{{For nowiki}}'s source
{{If then show}}'s source

Welcome to Code Golf! This is a really neat answer, never would've Wikimarkup was this capable.

Agreed. When I saw this I had a hunch that this was plagiarized from some code I wrote on Wikipedia, but it doesn't seem to be. That said, you can save 3 bytes by replacing
 with a literal newline, and I think you can save another few bytes by replacing "if then show" with "if empty", and another few by removing the trailing vertical bars after "Fizz" and "Buzz".

@RadvylfPrograms I think Wikitext would be Turing complete if it weren't for deliberate limitations imposed by the parser that a CGCC answer would probably ignore anyway

Snowman 1.0.2, 97 chars
)1vn101nR:du*_/3NmO0eQ)(#5NmO0eQ}~(~%@or(%nO?_/)#%@{%@tS?)aRsP@@"Fizz"_aRsP\"Buzz"aRsP?)10wRsP;aE

How does it work, you ask? ... I have no idea. I might edit in a full explanation at some point if I ever decide to try to understand this again.
(Pulled directly from Snowman's examples directory.)

GolfScript, 37 bytes
100,{)..3%!'Fizz'*\5%!'Buzz'*+\or n}/

sed 4.2.2 -r, 94 bytes
G
:
s/\n.?$/&0&1&2&3&4&5&6&7&8&9/m
t
s/\w.{8}/&Fizz /g
G
s/ *\w[05]|$/Buzz/2g
s/^0*\n*| .*//mg

Try it online
This is my old solution from anarchy golf, minus 5 backslashes gained by -r.
The loop generates 00 to 99 preceded by newlines. Next, we prepend Fizz  to lines 03, 06, ... taking advantage of the fact that the entry points are all separated by 9 characters. Then we handle instances of Buzz by looking for suffix of 0 or 5, plus an empty line to stand in for 100, and skipping the first match 00. The last line cleans up the garbage on the ends of Fizz-but-not-Buzz lines along with leading 0s and the first two lines.
Note: The behavior of mixing 2 and g flags in s is unspecified by POSIX but well-defined in GNU sed.
sed 4.2.2 (no -r), 98 bytes (based on a solution by tails)
s/\S\?/ 123456789/
s//&1 &2 &3 &4 Buzz &6 &7 &8 &9 Buzz /g
s/\([1 ]\S* .\S* \)[0-9]*/\1Fizz/g
L0
d

Try it online
Using a quite different approach, this solution wins by 1 byte when -r is not used. Thanks to @tails for sharing this approach with me!
The first two lines generate 1 to 100 separated by spaces with suitable Buzz replacements, along with an extra residual space before 11. To match for Fizz replacements, special care is needed to skip Buzz in multiples of 15 without skipping Buzz in 3k + 1 spots. We can do this by starting the pattern with a space, except that this does not work for the very first match, so [1 ] is used instead. The . in line 3 compensates for the extra space before 11, which is masked in the final output by L0.
L is a GNU-specific line formatting command that was "considered a failed experiment" and removed in later versions of sed.

Very cool, both the solutions. This is the first time I'm learning of L, I've added it as a sed golfing tip https://codegolf.stackexchange.com/a/220951

rSNBATWPL, 57 bytes
for{i=1;i<101}$print{(("Fizz"*1>i%3)+"Buzz"*1>i%5)or++$i}

RSNBATWPL, or Radvylf Should Not Be Allowed To Write Programming Languages, is a "practical" programming language I've designed over the last week or so. It aims to be a sort of "super-JS/PHP/C++": a language that seems practical to the uninitiated and allows writing nice code, but deep down, is horribly cursed.
This is a significantly golfed version of my more readable FizzBuzz program:
n = cast.int{input{"Input: "}};

for {i = 1; i <= n; ++$i} {
    cond {(i % 3) and (i % 5)} {
        print{i};
    } {
        s = "";

        if {not{i % 3}} {
            s += "Fizz";
        };

        if {not{i % 5}} {
            s += "Buzz";
        };

        print{s};
    };
};

It uses a few interesting golfs, like replacing function calls (with {}) with the $ operator (which calls a function with an argument). It also relies on rSN's weird parsing order, with things like +"Buzz"*1>i%5 only being possible because rSN is always parsed right-to-left. In this case, we also make use of multiplying a string by a bool, a type hack similar to what you'd see in JS.

D, 90 bytes
import std;void main(){foreach(i;1..101)i.text.max("FizzBuzz"[i%3?4:0..i%5?4:8]).writeln;}

Try it online!

Welcome to Code Golf, and nice answer!

Jellyfish, 124 105 98 97 92 87 bytes
P
L,L,  v"Buzz
1 1v"Fizz
   E $X$ S
 LvLjXX v*4
 1 0*rES2b30
  $R  *'e
  ,1N1b'䬴
  'd

Try it online!
Try the 92B version online!
Try the 97B version online!
Try the 98B version online!
Try the 105B version online!
Try the 124B version online!
explanation
The main idea is to concatenate each string from 3 string-arrays, numstr_array, fizz_array, buzz_array, to create 1 string-array, and matrix-print that with "P" function.
while a code-block like \$\left|\begin{array}{ll}L&,~~~~s\_ary2\\1&s\_ary1\end{array}\right|\$ create a string-array like
[ s_ary1[i]+s_ary2[i] for i in range(min(len(s_ary1),len(s_ary2))) ]
in Python,
\$\left|\begin{array}{ll}L&,~~L~~~,~~buzz\_array\\1&\downarrow~1~~fizz\_array\\~&numstr\_array\end{array}\right|\$ creates such a "concatenated" array.
The 3 string-arrays above should have these contents;

numstr_array: [ "1"  "2"  ""  "4"  ""  ""  "7"  "8"  ""  "" ... ]
fizz_array: [ ""  ""  "Fizz"  ""  ""  "Fizz"  ""  ""  "Fizz"  ""... ]
buzz_array: [ ""  ""  ""  ""  "Buzz"  ""  ""  ""  ""  "Buzz" ... ]

and the last 2 arrays are simply created from drop function "v".
2-parameter version of "v" takes num-array and a string, and create a string-array whose elements are "dropped" from the original string, like [ string[i:] for i in num_array ] in Python.
For example, \$\left|\begin{array}{}v&"&B&u&z&z\\~\\X&$&~&S\\~&~&~&*&4\\~&S&~&b&3&0\\~&'&e\end{array}\right|\$ code block creates the buzz_array.  The "num-array" in this block is a 101 elements of [ 4 4 4 4 0 4 4 4 4 0 ...]. ( 101 comes from the ASCII code of "e" at "'e" node )
The first array ( numstr_array ) is a little more complicated from the others. because the original strings ( before dropped ) are not the same unlike fizz_array or buzz_array are created from one original string for each.
To solve this problem, use \$\left|\begin{array}{ll} L & v ~~ str\_array \\ 1 & 2d\_num\_array\end{array}\right|\$ to "drop" each string independently.
str_array is created from a 0-array and a 1..100 sequence combined with \$\left|\begin{array}{ll} L & j ~~ sequence \\ 0 & 0\_array  \end{array}\right|\$.
2d_num_array is a 100x1 2d-array like [ [0] [0] [101] [0] [101] [101] [0] ... ], which is created as a repetition of a 15-length pattern [0 0 101 0 101 101 0 ...].

Heyo, welcome to code golf! This is quite a neat first answer, so keep up the good work!

Thx! I will add some code explanation after I prepare it.

i'm afraid 92 byte version is not working on TIO because of handling null input

Thank you for letting me know about the old sample on TIO was not working.  I fixed it and update this post.

I misunderstood the "header" area on TIO  as for title or some comment, and added a string on it.  That's why the code was not working.

JavaScript, 79 bytes
After a long time I tried to use JS again...
Thanks to @ShadowCat we made it to 79 bytes:
for(i=0,s="";i++<100;s+=(i%5?i%3?i:'Fizz':i%3?'Buzz':'FizzBuzz')+"\n");alert(s)

Old solution, 87 bytes:
for(i=2,s="1";i<101;s+="\n"+["FizzBuzz","Buzz","Fizz",i][(i%3>0)+2*(i++%5>0)]);alert(s)

I recommend dropping the semi-colon at the end. Also I just used conditionals i%5?i%3?i:'Fizz':i%3?'Buzz':'FizzBuzz' and I got 79 bytes, so I recommend trying that. I would also avoid s="1" and just start i=1,s="" to save an extra byte

I was working on a ?: solution but I was not able to get it to work before you commented=) Thank you very much! (Honestly I am still proud of my array indexing solution=P)

A trailing newline is acceptable, but a leading newline is not. I don't like this rule, but it's a rule nevertheless

77: change starting part i=s="". 76 using ES6 and template string for newline

75: i recomment this for(i=0,s="";i++<100;s+=((i%3?'':'Fizz')+(i%5?'':'Buzz')||i)+"\n");alert(s), because it saves 6

@NinaScholz Thanks! I am no more updating as there is another JavaScript version that is way shorter, by ETHproductions

Befunge-93, 82 81 bytes
I'm sure this could be golfed, but I think this is a good start.
1+:::3%:#v_"zziF"v>*|>25*,:"!"3*`#@_
v _v#:%5\<   ,,,,<^ >^
<  >\"zzuB",,,,   ^ .#

Try it in this online interpreter.

Attempts that didn't work
1+:::3%: #v_"zziF" v>*#v_>25*,:"!"3*`#@_
v _v#:%5\ <>#,,,,,#<^  >.^
<  >\"zzuB"^        ^

Tries to combine the printing of Fizz and Buzz. Ends up at 88 bytes.
Vertical rendition of the above
Forgot about newlines. 122 bytes. Ick. Without newlines it would be 122-41=81 bytes. Welp.

SQL (PostgreSQL flavour), 107 bytes
SELECT(array[n||'','Fizz','Buzz','FizzBuzz'])[1+(n%3=0)::int+(n%5=0)::int*2]FROM generate_series(1,100)a(n)

Same sort of logic as my R answer

bc, 83 bytes
Undeclared variables are zero by default, so i=0 can be omitted. The three line breaks are required.
for(;++i<101;){if(!i%15)"FizzBuzz
"else if(!i%5)"Buzz
"else if(!i%3)"Fizz
"else i;}

Haskell, 105 97 bytes
main=mapM(putStrLn.f)[1..100]
a%b=a`rem`b<1
f n|n%15="FizzBuzz"|n%3="Fizz"|n%5="Buzz"
f n=show n

I'm kinda new to Haskell, so any advice would be appreciated!

first line could be main=mapM(print . f)[1..100]

You can write all the guards of f in a single line: f n|n%15="FizzBuzz"|n%3="Fizz"|n%5="Buzz".

I count 96 bytes. If you write f 3++f 5 instead of "FizzBuzz", you can save two more. Also, henkma on anarchy golf has 82 somehow.

I posted an 85 byte answer.

MATLAB, 94 bytes
for i=1:100 t=mod(i,3);f=mod(i,5);s=[(t&f)*num2str(i) ~t*'Fizz' ~f*'Buzz' ''];disp(s(s>0));end

So this new code is a slight improvement on the one below. Rather than using arrayfun() which is quite costly in characters as it requires 'UniformOutput','false' to get it to work, I have simply made it a for loop - because the range of numbers is hard coded, there is no need to use a function as I had done in my last edit. Removing it from the function saves another 10 characters.
This does basically the same thing, but rather than making all the strings first, in makes them one by one in a for loop and displays them. This actually also means char() only has to be used once (in the other one it was used a second time to display everything). Having the loop means I can use variables to store the results of mod(i,3) and mod(i,5) so they don't need calculating twice. The nonzeros() function has also now been removed, instead opting for storing to a variable then only printing anything which is not equal to zero. This solution when you run it also doesn't print ans= before the first line.
Thanks to @flawr for the tips, saved 4 bytes.

Old code:
MATLAB, 118 bytes
char(arrayfun(@(x) char(nonzeros([(mod(x,3)&&mod(x,5))*num2str(x) ~mod(x,3)*'Fizz' ~mod(x,5)*'Buzz'])'),1:100,'Un',0))

A bit of fun with multiplying strings with scalars. Basically the output of ~mod(x,5) and ~mod(x,3) are multiplied by 'Fizz' and 'Buzz' respectively which produces either zeros (blanks) or one or both of the words. (mod(x,3)&&mod(x,5))) is basically when the number is neither a multiple of 3 nor 5 which is multiplied by the number as a string to get either zeros or the number.
These are then concatenated into an array which then has all of the zeros removed using nonzeros() and then resulting array transposed to be in the right direction for conversion to a character string.
Finally once all numbers have been processed by arrayfun(), the resulting cell array of arrays is passed to char() which converts it to a cell array of strings. Because there is no ; at the end of the string, the output is dumped to the console.

It might be possible to make it smaller, I'm looking ;)

I like your solution! Just some hints, you can use [s,''] instead of char(s) (I'd add that in the disp.) Then if you have arguments like UniformOutput it usually suffices to just write U or Un (just as many letters needed for discerning the different possible arguments) and instead of true,false you can use 1,0 (or for true any finite value bigger but zero). This also means instead of s~=0 you can use ~s or if this does not work s>0 or s<0 depending on the application.

@flawr Thanks for the tips. I hadn't realised that appending '' converted to a char string. I've saved 4 more bytes. Added the '' to the s=[  ] bit as it does the same as adding it in disp() but without the cost of the extra []. Also the s>0 was a bit of a duh moment on my part!

There is a Tipps for golfing in Matlab (and linked there one for golfing in Octave) might be worth reading (and expanding=). Happy golfing=)

Fortran, 213 bytes
character(len=8)::o
do i=1,100
if(mod(i,15)==0)then;write(*,*)'FizzBuzz'
elseif(mod(i,3)==0)then;write(*,*)'Fizz'
elseif(mod(i,5)==0)then;write(*,*)'Buzz'
else;write(o,'(i8)')i;write(*,*)adjustl(o)
endif;enddo;end

Not as graceful as the golf languages.  I could save bytes using print instead of write, but print indents 1 space without a format specifier which would increase the byte count instead.  Likewise I lose bytes printing the number because Fortran doesn't like left-justified output for numbers.  I didn't bother sticking it all on one line as newlines and semicolons are both 1 byte -- no savings.

Could possibly save bytes by setting a variable and writing it out once at the end, instead of multiple write statements.

Pip, 32 31 30 bytes
LhP J["Fizz""Buzz"]X!*Ui%^35|i

Attempt this online!
Here's the 31-byte equivalent in Pip Classic: Try it online!
Explanation
LhP J["Fizz""Buzz"]X!*Ui%^35|i
                                Preinitialized variables: h=100, i=0
Lh                              Loop 100 times:
                         ^35     Split 35 into a list of digits: [3 5]
                      Ui         Pre-increment i (thus starting at 1, not 0)
                        %        Mod (vectorizing); our list is now [i%3 i%5]
                    !*           Map logical not to that list (1 if mod was 0, else 0)
     ["Fizz""Buzz"]              List containing Fizz and Buzz
                   X             Repeat string (vectorizing)
                                 Our two items are now:
                                  "Fizz" if i is divisible by 3, "" otherwise
                                  "Buzz" if i is divisible by 5, "" otherwise
    J                            Join that list into a single string
  P                         |i   Logical OR with i, and print

TI-BASIC, 59 bytes
For(X,1,ᴇ2
int(ln(gcd(X,15→J              ;[3 divides X] + [5 divides X]
X
If J
sub("FizzBuzz",7-2gcd(X,3),4J
Disp Ans
End

Or at the same length:
For(X,1,ᴇ2
gcd(X,15→J
X
If ln(J
sub("FizzBuzz",5^(J=5),4int(ln(J
Disp Ans
End

Both programs use the fact that ⌊ln(3)⌋ = ⌊ln(5)⌋ = 1 and ⌊ln(15)⌋ = 2.
There could be another byte to golf off somewhere, but I can't find it. By comparison, here's the naïve approach at 67 bytes:
For(X,1,ᴇ2
"Fizz
If fPart(X/3:X
If not(fPart(X/5:"Buzz
If not(fPart(X/15:"FizzBuzz
Disp Ans
End

TI-BASIC's quirks lengthen the program in two ways:

TI-BASIC needs two bytes to encode every lowercase letter other than i (which represents the imaginary unit).
Empty strings are not supported: sub("FizzBuzz",5,0 and ""+"Buzz" both throw errors.

Wouldn't moving X to the 2nd to last line shave a byte? (Disp X?) (For the seond one)

Here are my suggested revisions (I don't have my calculator handy, so I'm not sure if it remains the same.)

Ohhhh I see. The Ans functionality sometimes confuses me. Sorry if I sounded pretentious ;)

I found a byte on the "naive" solution by storing "Buzz" to Str2 then "Fizz" to Str1 at the beginning of the loop, leaving "Fizz in Ans so lines 5 and 6 can use Str2 and Str1+Str2.
Also by my byte counts following token size here:
http://tibasicdev.wikidot.com/one-byte-tokens
The naive solution is 70 bytes to the above 69.  Between the optimal solutions, the one that does not precompute int(ln( on gcd(X,15 should be the smallest at 60 bytes to 61 for the other.

Groovy, 69 Bytes
(1..100).each{i->println i%15?(i%5?(i%3?i:'Fizz'):'Buzz'):'FizzBuzz'}

Can save 2 bytes using 1.upto(100){} and no parenthesis are needed in your answer, resulting in: 1.upto(100){i->println i%15?i%5?i%3?i:'Fizz':'Buzz':'FizzBuzz'} +1 though :).

Transact-SQL, 163 143 124 110 bytes
This requires SQL Server 2012+
(thanks MickyT for the unnamed variable and the IIF suggestions, changed to muqo's GOTO loop instead of WHILE)
declare @ int=1a:print iif(@%3*@%5>0,ltrim(@),iif(@%3=0,'Fizz','')+iif(@%5=0,'Buzz',''))set @+=1IF @<101GOTO a

Formatted and explained:
declare @ int=1                      --@ is a valid variable name
a:                                   --shorter than WHILE
    print iif(@%3*@%5>0, ltrim(@),   --ltrim is shorter than explicit cast
          iif(@%3=0,'Fizz','')       --nest the IIFs
        + iif(@%5=0,'Buzz',''))
    set @+=1
IF @<101 GOTO a

Hello, and welcome to PPCG! Great answer! Can you please add an explanation?

Sure thing I'll include the ungolfed version, it's just a while loop

I feel a bit privileged that in many languages you can't use expressions in case statements, but also a bit sad that the Oracle SQL person got fewer bytes...

@MickyT thanks for the advice! However the way you wrote it produces FiBuzz for 15 and others, just FYI, and the @ number needs to be cast to a string

@MickyT got it down to 143 thanks to your suggestions!

Sorry about that, SQL fiddle didn't want to play for me..

You may want to try the last iif with no cast and a NULL instead of an empty string, otherwise the concat can be replaced with +.  don't know what i was thinking when I first suggested it.  also char may work if the cast can't be removed.

I think casting to char might violate the rules of the contest, since it will pad with spaces when the number is less characters than the specified amount...

@MickyT the iif(@ % 3 * @ % 5 <> 0, @ , null) worked great, wow

Using + instead of concat made it to where the cast would be needed again, so based on character count I stayed with concat

Good work, but this needs more golfing.  Use GOTO, not WHILE.  Skip CONCAT because you need to force only @ to be a string, so just enclose it in LTRIM or something.  Use + for the Fizz and Buzz IIFs, and nest that in the IIF for the other numbers.  Remove as many spaces as possible.  I can get your entry down to 110 doing all that.

Code and explanation didn't match. Took the opportunity to edit in @Muqo's suggestions.

APL, 41 bytes
⊣{⎕←∊(z,⍱/z←0=3 5|⍵)/'Fizz' 'Buzz'⍵}¨⍳100

Tested on GNU-APL (ver 1.7/980M)

Do you need the space between ' and ⍵?

Oh, I haven't used GNU APL in a while, is the ⊣ needed, since you display directly to STDOUT?

@Zacharý In GNU-APL monadic 'left tack' discards the value of the right argument. I read it as return nothing (since it points to left). I hope this is the correct way to phrase it. on the other hand, I do not have experience with Dyalog or a ready-setup to play with.

Oh, for some reason I was thinking the return value was not written to STDOUT by default.

It's not in Dyalog, but it is in GNU.

You can shave off another byte by transposing the top-level /, which removes the need for the parentheses: ⊣{⎕←∊'Fizz' 'Buzz'⍵/⍨z,⍱/z←0=3 5|⍵}¨⍳100

Fortran, 187 bytes
do i=1,100
if(mod(i,3)==0.and.mod(i,5)==0)then;print'(a)','fizzbuzz'
elseif(mod(i,3)==0)then;print'(a)','fizz'
elseif(mod(i,5)==0)then;print'(a)','buzz'
else;print'(i0)',i
endif;enddo;end

Welcome to PPCG!

...change print'(a)' etc. to print* to save 16 bytes

I never used print* as it prints the characters with a space or two before hand, thus it doesn't match the required format.

You can change end if to endif and save one byte :)

MathGolf, 24 22 bytes
♀{î╕Σ╠δ╕┌╠δ`+Γî35α÷ä§p

Try it online!
Explanation
♀                         Push 100
 {                        Start block
  î                       Push loop counter (1-indexed)
   ╕Σ╠δ                   Decompress "Σ╠" and capitalize to get "Fizz"
       ╕┌╠δ               Decompress "┌╠" and capitalize to get "Buzz"
           `              Duplicate top 2 elements of stack
            +             Add (creating "fizzbuzz")
             Γ            Wrap top 4 elements of stack in array
              î           Push loop counter (1-indexed)
               3          Push 3
                5         Push 5
                 α        Wrap last 2 elements in array
                  ÷       Check divisibility (implicit mapping)
                   ä      Convert from binary to int
                    §     Get array item
                     p    print
                          End block on code end, for loop implicit (100 iterations)

@dzaima Darn, I forgot about that completely. I have however had a capitalization operator in mind for a while. That should add one byte to the solution, but it is not yet implemented.

I fixed the capitalization, at the cost of two bytes.

brainfuck, 628 499 bytes
+[>>+>>+++<<[>+>->+<[>]>[<+>-]<<[<]>-]>>>[>>]<[>-[------->+<]>---.[--<+++>]<.-[---<+>]<-..<<<<[-]>>>>>>]<[-]<[-]<[-<+>]>+++++<<[>+>->+<[>]>[<+>-]<<[<]>-]>>>[>>]<[-[++++>---<]>-.++[-----<+>]<+.+++++..<<<<[-]>>>>>>]<[-]<[-]<[-<+>]<<<[[-]>>[-<+>>+<]>>>++++++++++<<[->+>-[>+>>]>[+[-<+>]>+>>]<<<<<<]>>>>>++++++++++<[->-[>+>>]>[+[-<+>]>+>>]<<<<<]>[-]>>[>++++++[-<++++++++>]<.<<+>+>]<[<[->-<]++++++[->++++++++<]>.[-]]<<++++++[-<++++++++>]<.[-]<[-]<[-<+>]<[-]<<[->+<]<]++++++++++.>>[-<+>>+<]-[<-->-----]<++]

This took me WAY too long. It's an extremely naive implementation with two divmods and a printing bit for Fizz and Buzz, as well as an equality check for 100. All in all not really golfed. At all. Not even a little bit. But it was fun, as this was my first ever real brainfuck program.
I started this by purposely not looking at any of the other brainfuck answers, partly so I wouldn't get discouraged, and partly so I wouldn't even subconsciously use any other ideas.
Any feedback or shrinkings are appreciated!
Badly commented source code
Try it online!

Some quick golfing; There's some leftover whitespace in the code, and all the [-]s can be replaced with ,s (if you're okay with EOF being 0). At least one of the [-]s isn't necessary. The not of the modulo will probably be shorter with forking the movement instead ([>>]<), making sure the tape ends up the same afterwards

I don't think any of my implementations support EOF as 0, but I am interested in the unnecessary [-] clear cell and the [>>]<. Is there a chance you can suggest an edit?

596 bytes without whitespace and redundant [-]s. I think you'll find that most implementations use 0 as the EOF, and even the ones that don't usually use -1/255, which is still one byte shorter. I guess there's also no change, but that's rare. I'll work on the [>>]< part

499 bytes. I've changed it to the [>>]< method I mentioned above, and golfed some other parts. I didn't really touch the print as a number part, so you can probably golf something there.

Seed, 6015 bytes

186 [encoded data, 6011 characters]

Try it online!

Oh, my generator must have glitched. I'll look on this

@JoKing Well, I should have tested my stuff before. Now it works

Arn -hm, 27 22 18 bytes
─=█BƒHXåõÝü»ÝÑÕ=!&

Try it!
Explained
Unpacked: "Fizz"^!%3|`#&`^!%5||
Set STDIN to the range [1, 100]

      "Fizz" Literal string
    ^ Repeat
      ! NOT
          _ Implied variable
        % Modulo
          3
  | Concatenated with
      `#&` Compressed string "Buzz"
    ^
      !
          _ Implied
        %
          5
|| OR
  _ Implied

Mapped over STDIN with key`_

I wasn't going to update this, but might as well.

GNU sed 4.2.2, 126 bytes
This answer is in response to the bounty offered by @user41805 to golf further his sed script for this challenge.
s/^/@@,/;h
:
y/@123456789';,/123456789@;,'/
/@.$/!{x;G;s/..\n.//}
h
s/[@5].$/&Buzz/
s/.*,/Fizz/
s/.*\WB/B/
s/\W*//gp
g;/@@/d
t

Try it online!
The trick was to notice that no '0' will be printed, so I replaced it with '@' to be able at line 9 to refer to the extra characters [0';] as \W, thus shaving 3 bytes. Please check his description on how the code works.

Vyxal, Hj, 25 19 12 bytes
-6 bytes thanks to Aaron
-7 bytes thanks to lyxal
Flagless 15 bytes
Longer than lyxal's answer, but uses a different technique
ƛ₃kf*n₅kb*+∴               stack is preset to a 100 because of the `H` flag

ƛ                          lambda map with variable n
 ₃                         push 1 if n%3 == 0 (we'll call the return a)
  kf                       push constant Fizz to the stack
    *                      push a*kF
     n                     push n
      ₅                    push 1 if n%5 == 0 (we'll call it b)
       kb                  push Buzz to the stack
         *                 push b*kB
          +                add last two elements of the stack ""/Fizz/Buzz
           ∴               push the maximum of n and ""/Fizz/Buzz/FizzBuzz

Vyxal prints out the last element of the stack by default (the `j` flag joins the list with new lines)

Try it Online!

You can use the register instead of variables, and the H flag, for 19 bytes

Try it Online! for 16 bytes using the register, H flag and string multiplication instead of if statements

Try it Online! for 12

@lyxal and Aaron Thanks!

@lyxal would you please check the explanation? I didn't get the last part so i guessed

The explanation is all good

Apple shortcut language, 31 actions, 23580 bytes

Here's a link that'll open it in iOS. Warning: May brick your device, use with caution.
Here's a downloadable file that can be imported on MacOS. The size of this file is the score.
This was a huge pain, especially taking and combining all the screenshots for the above image. The language has several annoying bugs features though:

The 'add to variable' action treats it as a list, even if it's a number
There's no way to create a range
There's one output, so you have to combine everything into that
very basic list support only
No way to do a while loop / break out of a loop

It's sorta equivalent to the pseudocode:
O = []
C = 0
repeat 100:
  T = ''
  C += 1
  if C % 3 == 0:
    T += 'Fizz'
  if C % 5 == 0:
    T += 'Buzz'
  if T == '':
    T = C
  O += T
print '\n'.join(O)

Is this real language?

If anyone on iOS isn’t seeing any results it didn’t actually display anything for me until I added a “show result” block to display the O variable.

I’ve got 25 actions, including a “show result”. iOS link

@AaroneousMiller It displays just fine on my end when editing+running the script

@AaroneousMiller Because of annoying iOS settings I can't open that, feel free to post it yourself.

So it turns out that my 25 action one had a leading newline, which is not allowed, so here’s a valid one with only 19 actions :P iOS link

Oh, I didn’t refresh the page, so I didn’t see your comments. I’ll go ahead and post the 19 action one then.

Aya, 37 bytes
[100,Y""y3%0="Fizz"?y5%0="Buzz"?+:P];

I recently discovered Aya (so this code is likely not optimal), but really want to spread the word.
How it works
First, here are all the relevant operators:
[<number>,<expression>]  | performs a list comprehension
                         | by taking all numbers from 1 to <number> (inclusive)
                         | and applying the expression to that number

Y                  | copies the value at the top of the stack into y
""                 | puts an empty string on the stack
<num a> <num b> %  | pop the topmost two values, store a mod b on stack
<num a> <num b> =  | pop the topmost two values, store a equals b on stack
<any a> <any b> ?  | pop the topmost two values, if a is truthy: keep b on stack
<any a> <any b> +  | pop the topmost two values, store concatenation of a and b on stack
<any a> :P         | pop the topmost value, format a as string, perform println
;                  | pop the topmost value

The main "gimmick" here, is that + only operates on the topmost two values.
So by placing [y ""] on the stack first, any addition to the stack will push y out of the scope of +.
Conditionally adding "Fizz" and "Buzz" to the stack leaves us with 4 possible compositions when + is executed:

[y ""] - when y is not divisible by 3 or 5
[y "" "Fizz"] - when y is divisible by 3 but not 5
[y "" "Buzz"] - when y is not divisible by 3 but is divisible by 5
[y "" "Fizz" "Buzz"] - when y is divisible by 3 and 5

The list comprehension captures anything that remains on the stack as elements of the list, so we can drop all of the junk with a single ; at the end.
For the curious, this is what remains in the list:
[ 3 5 6 9 10 12 15 "" 18 20 21 24 25 27 30 "" 33 35 36 39 40 42 45 "" 48 50 51 54 55 57 60 "" 63 65 66 69 70 72 75 "" 78 80 81 84 85 87 90 "" 93 95 96 99 100 ]

Welcome to Code Golf! Nice answer.

Perl 6, 109 93 bytes
for$i(1..100){if($i%3<1){say"Fizz"};if($i%5<1){say"Buzz"};if($i%3>0&&$i%5>0){say$i};say"\n";}

There might be some more golfing potential here.
Takes advantage the fact that 0 is the only way x % y can be less than 1 (thanks to Alex. A for shaving off 4 bytes with this) and Perl 6's say keyword.

I didn't spot this somehow... Sorry, If you'd like to adopt some of the ideas in my answer you can save more bytes! say is available in Perl 5 too for free (http://meta.codegolf.stackexchange.com/q/273#answer-274) and it includes a newline (which would further shorten mine by 5 bytes). Happy to remove mine (since it's newer than yours).

C (83 characters)
Because misusing a (POSIX conformant) printf is not that bad, after all:
i;main(){while(++i<101)printf(i%3?i%5?"%2$d\n":"%s\n":"Fizz%s\n",i%5?"":"Buzz",i);}

Lua, 88 86 bytes
Saved 2 bytes thanks to @Mauris
I'm sure this can be golfed more, any suggestions are welcome.
for i=1,100 do n=(i%3<1 and"Fizz"or"")..(i%5<1 and"Buzz"or"")print(n~=""and n or i)end

Try i%3<1 and i%5<1?

82 bytes: for i=1,100 do s=('Fizz'):sub(i%3*5)..('Buzz'):sub(i%5*5)print(s==''and i or s)end

I posted a 72-byte solution that ties the record on anarchy golf.

PowerShell, 59 58 bytes
Original used array selection, but was one byte longer than a minor variation of TimmyD's answer
old: 1..100|%{@($_,"Fizz","Buzz","FizzBuzz")[!($_%3)+2*!($_%5)]}

new: 1..100|%{"Fizz"*!($_%3)+"Buzz"*!($_%5)+"$_"*!!($_%3*$_%5)}

The only real trick involving use of double negation to make anything non-zero a 1 while leaving a zero a zero.
I would have left this as a comment on TimmyD's answer, but I lack the reputation.

EDIT: GAH! I see, now, that the original array implementation was naive insofar as my not having read through the other solutions and realizing that it was already in use ... multiple times over. I leave it here, but shamefacedly admit my ignorance.

Welcome to PPCG! Nice to see another PowerShell user around. Neat trick with the array-indexing, and further proof that PowerShell is nothing if not flexible. Note that, in this particular instance, you don't need to prepend the @ symbol, since PowerShell treats any comma-separated list as an array, saving a byte on that guy and making the two the same length. See an update on my answer as well, incorporating other suggestions.

SWI-Prolog, 109 bytes
forall(between(1,100,I),((I mod 3<1,print('Fizz');1=1),(I mod 5<1,print('Buzz');I mod 3>0,print(I);1=1),nl)).

How is this supposed to be run? I would suggest +X:-print(X)., but it appears this is run from the REPL. Néanmoins, I mod 3>0,print(I);1=1 can become I mod 3<1;print(I). Also anagol has 87 bytes (in anagol, the m/0 predicate is run) for FizzBuzz http://golf.shinh.org/p.rb?FizzBuzz#Prolog

Beam, 307 288 bytes
And now for the longest solution.  I think I could compress this a bit more, but the brain is getting a little fried.  I'm pretty happy I got it working though.  Rearranged it slightly to gain a few.
+P'++P'++P'''''''>`++ \/+)@'''''>`+++++++)@' \
v```P'''----(+++++++++/+/P+++'L@@++(+++++`<''/
>'p-`n'''''''>`++++++++/
^    >'P'p-``n'         >'p-``n'''''''''''>`++++++)@'''''''>`++ \
^       <    >p:L''p-``       >''P``v
^      Hu```P-p'''L@++++++++++LP+p  <``P+++++''L@@+++++@++(+++++/

var ITERS_PER_SEC = 100000;
var TIMEOUT_SECS = 50;
var ERROR_INTERRUPT = "Interrupted by user";
var ERROR_TIMEOUT = "Maximum iterations exceeded";
var ERROR_LOSTINSPACE = "Beam is lost in space";

var code, store, beam, ip_x, ip_y, dir, input_ptr, mem;
var input, timeout, width, iterations, running;

function clear_output() {
document.getElementById("output").value = "";
document.getElementById("stderr").innerHTML = "";
}

function stop() {
running = false;
document.getElementById("run").disabled = false;
document.getElementById("stop").disabled = true;
document.getElementById("clear").disabled = false;
document.getElementById("timeout").disabled = false;
}

function interrupt() {
error(ERROR_INTERRUPT);
}

function error(msg) {
document.getElementById("stderr").innerHTML = msg;
stop();
}

function run() {
clear_output();
document.getElementById("run").disabled = true;
document.getElementById("stop").disabled = false;
document.getElementById("clear").disabled = true;
document.getElementById("input").disabled = false;
document.getElementById("timeout").disabled = false;

code = document.getElementById("code").value;
input = document.getElementById("input").value;
timeout = document.getElementById("timeout").checked;

code = code.split("\n");
width = 0;
for (var i = 0; i  width){
  width = code[i].length;
 }
}
console.log(code);
console.log(width);

running = true;
dir = 0;
ip_x = 0;
ip_y = 0;
input_ptr = 0;
beam = 0;
store = 0;
mem = [];

input = input.split("").map(function (s) {
  return s.charCodeAt(0);
 });

iterations = 0;

beam_iter();
}

function beam_iter() {
while (running) {
 var inst;
 try {
  inst = code[ip_y][ip_x];
 }
 catch(err) {
  inst = "";
 }
 switch (inst) {
  case ">":
   dir = 0;
   break;
  case "<":
   dir = 1;
   break;
  case "^":
   dir = 2;
   break;
  case "v":
   dir = 3;
   break;
  case "+":
   ++beam;
   break;
  case "-":
   --beam;
   break;
  case "@":
   document.getElementById("output").value += String.fromCharCode(beam);
   break;
  case ":":
   document.getElementById("output").value += beam;
   break;
  case "/":
   dir ^= 2;
   break;
  case "\\":
   dir ^= 3;
   break;
  case "!":
   if (beam != 0) {
    dir ^= 1;
   }
   break;
  case "?":
   if (beam == 0) {
    dir ^= 1;
   }
   break;
  case "|":
   switch (dir) {
   case 2:
    dir = 3;
    break;
   case 3:
    dir = 2;
    break;
   }
   break;
  case "_":
   switch (dir) {
   case 0:
    dir = 1;
    break;
   case 1:
    dir = 0;
    break;
   }
   break;
  case "H":
   stop();
   break;
  case "S":
   store = beam;
   break;
  case "L":
   beam = store;
   break;
  case "s":
   mem[beam] = store;
   break;
  case "g":
   store = mem[beam];
   break;
  case "P":
   mem[store] = beam;
   break;
  case "p":
   beam = mem[store];
   break;
  case "u":
   if (beam != store) {
    dir = 2;
   }
   break;
  case "n":
   if (beam != store) {
    dir = 3;
   }
   break;
  case "`":
   --store;
   break;
  case "'":
   ++store;
   break;
  case ")":
   if (store != 0) {
    dir = 1;
   }
   break;
  case "(":
   if (store != 0) {
    dir = 0;
   }
   break;
  case "r":
   if (input_ptr >= input.length) {
    beam = 0;
   } else {
    beam = input[input_ptr];
    ++input_ptr;
   }
   break;
  }
 // Move instruction pointer
 switch (dir) {
  case 0:
   ip_x++;
   break;
  case 1:
   ip_x--;
   break;
  case 2:
   ip_y--;
   break;
  case 3:
   ip_y++;
   break;
 }
 if (running && (ip_x < 0 || ip_y < 0 || ip_x >= width || ip_y >= code.length)) {
  error(ERROR_LOSTINSPACE);
 }
 ++iterations;
 if (iterations > ITERS_PER_SEC * TIMEOUT_SECS) {
  error(ERROR_TIMEOUT);
 }
}
}

Code:

    <textarea id="code" rows="6" style="overflow:scroll;overflow-x:hidden;width:90%;">+P'++P'++P'''''''>`++ \/+)@'''''>`+++++++)@' \
v```P'''----(+++++++++/+/P+++'L@@++(+++++`<''/
>'p-`n'''''''>`++++++++/
^    >'P'p-``n'         >'p-``n'''''''''''>`++++++)@'''''''>`++ \
^       <    >p:L''p-``       >''P``v
^      Hu```P-p'''L@++++++++++LP+p  <``P+++++''L@@+++++@++(+++++/
 </textarea>

        <input id="run" type="button" value="Run" onclick="run()">
        <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="disabled">
        <input id="clear" type="button" value="Clear" onclick="clear_output()">

Output:

    <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea>

Input:

    <textarea id="input" rows="1" style="overflow:scroll;overflow-x:hidden;width:90%;"></textarea>

Timeout:
        <input id="timeout" type="checkbox" checked="checked">

Explanation
+P'++P'++P'''''''>`++ \
v```P'''----(+++++++++/

Initializes the program, presetting values in memory
Memory 0, value 1, count incrementer
Memory 1, value 3, div 3 decrementer
Memory 2, value 5, div 5 decrementer
Memory 3, value 99, loop decrementer
>'p-`n
     >'P'p-``n
             >p:L''p-``

Gets value from Memory 1, decrements it, sets Store to 0.  If value <> 0 change direction down, otherwise pass though.
Do the same with Memory 2.  Finally if it gets down there, print out the current counter from memory 0.
                       /+)@'''''>`+++++++)@' \
                       +/P+++'L@@++(+++++`<''/
      '''''''>`++++++++/

Prints Fizz and resets memory slot 1 to 3.
                    >'p-``n'''''''''''>`++++++)@'''''''>`++ \

                                 ``P+++++''L@@+++++@++(+++++/

Another div 5 checker to catch FizzBuzzs. Prints out Buzz and resets memory slot 2 to 5.
                              >''P``v
       Hu```P-p'''L@++++++++++LP+p  <

Increments the counter, prints a newline, decrements the loop counter and exits if required.

awk, 62
END{for(x="Fizz";i<100;y="Buzz")print++i%15?i%5?i%3?i:x:y:x y}

Pretty sure there's no surprises here.
Call
awk 'END{for(x="Fizz";i<100;y="Buzz")print++i%15?i%5?i%3?i:x:y:x y}'

then press Ctrl-D to signal end of input.

I'm curious if the Ctrl-D should be included in the byte-count. Using a BEGIN block and rearranging the operators a bit adds 1 byte, i.e.  BEGIN{for(x="Fizz";i<100;y="Buzz")print++i%3?i%5?i:y:i%5?x:x y}

SQL (Oracle), 112 108 bytes
SELECT NVL(DECODE(MOD(LEVEL,3),0,'Fizz')||DECODE(MOD(LEVEL,5),0,'Buzz'),LEVEL)FROM DUAL CONNECT BY LEVEL<101

db<>fiddle here

''||LEVEL can be simple replaced with level

Python 3, 59 bytes
Based on @feersum's answer.
for i in range(100):print(i%3//2*"fizz"+i%5//4*"buzz"or-~i)

looks like this has the wrong capitalization

Seriously, 36 bytes
2╤R`;;3@%Y"Fizz"*)5@%Y"Buzz"*(+;I`Mi

Explanation:
2╤   push the value 10**2 (100)
R       pop a: push range(1,a+1)
`       start function literal
  ;;      duplicate the top of the stack twice
  3       push the value 3
  @       swap the top 2 values
  %       pop a,b: push a%b
  Y       pop a: push 1 if a==0, else 0
  "Fizz"  push the string "Fizz"
  *       pop a,b: push a*b (in this case, "Fizz" repeated b times)
  )       rotate the stack right by one ([a,b,c] -> [c,a,b])
  5@%Y"Buzz"*   Do the same thing as above, but with divisibility testing for 5 and using "Buzz"
  (       rotate the stack left by one
  +       pop a,b: push a+b (string concatenation here)
  ;       dupe top of stack
  I       pop a,b,c: push b if a is truthy, else c (here, a and b are the same string, either "", "Fizz", "Buzz", or "FizzBuzz", and c is the original integer)
`       end function literal
M       pop f,[a]: using each element of [a] as a temporary stack, evaluate f, and push the result
i       flatten [a] (push each value in [a] to the stack, starting from the end to preserve order)

Try it online.

Methinks you need a logical NOT in Seriously.

@ThomasKwa Maybe. I was wishing it had one while I was writing this. Seriously has ~, which is unary bitwise negation, which is not quite the same thing. I might add one.

Perl 6, 46 bytes
say "Fizz"x $_%%3~"Buzz"x $_%%5||$_ for 1..100

You can remove the spaces after x

Python 2 REPL, 54
0;exec"print _%3/2*'Fizz'+_%5/4*'Buzz'or-~_;_+=1;"*100

Based on this answer by feersum.
Essentially the same technique, only using Python's underscore variable to save 2 chars at the start.

Word VBA, 124 189 bytes
Sub f()
For i=1 To 100
r=""
If i Mod 3=0 Then r="Fizz"
If i Mod 5=0 Then r=r & "Buzz"
If r="" Then r=i
Debug.?r
Next
End Sub

The code breakdown is fairly simple (yay, BASIC).

Loop from 1 to 100
For i=1 To 100

Set a variable to be an empty string
r=""

Check the value on the counter to see if we should set the variable to Fizz
If i Mod 3=0 Then r="Fizz"

Check the counter to see if we need to add Buzz (adding it to an empty string is the same as setting that variable to Buzz)
If i Mod 5=0 Then r=r & "Buzz"

Check to see if the variable is still empty and therefore needs to be set to the counter value
If r="" Then r=i

Prints the results to the immediate window
t = t & r & vbCr

EDIT: Used @Taylor-Scott's suggestions to tighten it up. Relies on the meta discussion about counting characters when your IDE forces whitespace. Specifically the conclusion that if you can paste the code from the answer into the IDE and run it without issues, then you don't have to count the results of autoformatting.

Actually, the spacing after paragraphs is just a display thing. The plain text output will not have this spacing. :-) If you could add a code breakdown and explanation, this would have my upvote.

Yes, those are the words I was looking for. Ta!

+1, as promised! I have however noticed some irritating spaces around certain operators; can those be removed, or is it a language "feature"?

@wizzwizz4 Unfortunately, those spaces are a limitation of the language. The IDE forces them in there and you can't get around using the IDE. One of the many, many reasons that VBA is not a good candidate for code golf.

@phrebh can you write in a non-IDE e.g. notepad++, textedit, etc. and run as VB?

@phrebh the spaces are a "readability feature" of the VBE, not a limitation of the language AFAIK; I believe the code would still be valid VBA (per language specs) without the extra spaces that the VBE puts in.

You can drop quite a few bytes by following the tips that the community has outlined here,  - of note you should consider outputting via Debug.? rather than to the document - using this you should be able to get this down to 110 bytes or less

The IDE force-converts Debug.? to Debug.Print

@Selkie Yes, but as pointed out by Taylor Scott, the entered number of characters is what matters.

Javascript, 64 bytes
for(i=0;++i<101;)console.log((i%5?'':'fizz')+(i%3?'':'buzz')||i)

I'm not sure, but I think we allow alert for js output which would save you a few bytes. Nice answer btw.

We do allow alert.

All of the other JS answers on this particular challenge use console.log, except for one that outputs the entire text at once.

8086 machine code, 70 68 62 bytes
00000000  31 c0 40 50 89 c2 89 e5  68 0a 24 d4 05 75 06 68  |1.@P....h.$..u.h|
00000010  7a 7a 68 42 75 89 d0 d4  03 75 06 68 7a 7a 68 46  |zzhBu....u.hzzhF|
00000020  69 89 d0 83 fc fa 75 08  d4 0a 86 c4 0d 30 30 50  |i.....u......00P|
00000030  b4 09 89 e2 cd 21 89 ec  58 3c 64 75 c5 c3        |.....!..X<du..|
0000003e

How it works:
            |   org 0x100
            |   use16
31 c0       |       xor ax, ax
40          |   aa: inc ax
50          |       push ax
89 c2       |       mov dx, ax
89 e5       |       mov bp, sp
68 0a 24    |       push 0x240a
d4 05       |       aam 5
75 06       |       jnz @f
68 7a 7a    |       push 0x7a7a
68 42 75    |       push 0x7542
89 d0       |   @@: mov ax, dx
d4 03       |       aam 3
75 06       |       jnz @f
68 7a 7a    |       push 0x7a7a
68 46 69    |       push 0x6946
89 d0       |   @@: mov ax, dx
83 fc fa    |       cmp sp, -6
75 08       |       jne @f
d4 0a       |       aam 10
86 c4       |       xchg al, ah
0d 30 30    |       or ax, 0x3030
50          |       push ax
b4 09       |   @@: mov ah, 0x09
89 e2       |       mov dx, sp
cd 21       |       int 0x21
89 ec       |       mov sp, bp
58          |       pop ax
3c 64       |       cmp al, 100
75 c5       |       jne aa
c3          |       ret

This is very nice and very clean work!  Using the stack is quite elegant! Technically PUSH immediate was not available on the 8086, so this is really 80186+ machine code. Also, not sure if it's allowed or not, but this does show leading 0's on single digit numbers (01 02 Fizz 03, etc).

TeX, 304 bytes
\documentclass[9pt,a4paper]{article}\pagestyle{empty}\begin{document}\count0=0\count1=0\count3=3\count5=5\loop\advance\count1 by1\count0=0
\ifnum\count1=\count3 Fizz\advance\count3 by3\count0=1\fi\ifnum\count1=\count5 Buzz\advance\count5 by5\count0=1\fi\the\count1

\ifnum\count1<100\repeat\end{document}

Somehow count0 is necessary but I didn't check whether it is zero. It works and I have no idea why.

I'm assuming that extra newline is there for a reason, but what's the reason?

@StepHen two newlines is a new paragraph

Excel VBA, 81 Bytes
Anonymous VBE immediate window function that takes no input and outputs to the VBE immediate window.
For i=1To 100:o=IIf(i Mod 3,"","Fizz")+IIf(i Mod 5,"","Buzz"):?IIf(o="",i,o):Next

Ungolfed
For i=1To 100                   ''  iterate from 1 to 100
    o=IIf(i Mod 3,"","Fizz")    ''  set the out var to `Fizz` if i Mod 3 = 0, else empty
     +IIf(i Mod 5,"","Buzz")    ''  append `Buzz` to out var if i Mod 5 = 0
    ?IIf(o="",i,o)              ''  If out var is non-empty, output the out var
                                ''      else output i
Next

Worksheet Version, 95 Bytes
Anonymous VBE immediate window function that takes no input and outputs to the range [A1:A100]
 [A1]="=Let(r,Row(1:100),s,If(Mod(r,3),"""",""FIZZ"")&If(Mod(r,5),"""",""BUZZ""),If(s="""",r,s))

You can remove o="": and change your first iif to IIf(i Mod 3,"","Fizz")

For the Subroutine version, the () after F isn't optional, and gets added in automatically. Same with the ? in debug.

@Selkie, the behavior you are describing is known as autoformatting, and it is generally accepted in this community for VBA and for all languages that exhibit autoformatting, one may post their code from before it is autoformatted. in this case, that would mean that a couple of spaces may be removed, terminal "s dropped, changing print to ? and removal of the () from the Sub declaration. I suggest that you take a look at the Tips for Golfing in VBA page for more info

Befunge-93, 61 bytes
1+::::3%|>.#_:"c"`#@_55+,
,,:,,0\v>"ziF"
,:,,$01>>5%#v_"zuB",

Try it online!
Decided to come back to this and make it conform to specification while shaving some bytes off. Look, no extra spaces!

Symbolic Python, 324 bytes
I think I fried my brain making this...
_____=_;_=-~(_==_);___=_**(_*_+_);____=___+___/_+_+_
___=(('%'+`'¬'`[-_])*_)%(___+_,___*_-_*_-_)
___=`_>_`[_>_]+`__`[_*_+_]+___[~-_]*_,___[-_]+`__`[_]+___[~-_]*_
_=_>_
__('____=""'+(';_=-~_;____+=((_%-~-~(_==_)<(_==_))*___[_>_]+(_%-~-~-~-~(_==_)<(_==_))*___[_==_]'+`_____`[_==_]+`_==_`[_==_]+'`_`)+'+`"""
"""`)*____)
_=____

Try it online!

><>, 59 bytes
0v!oo:oo"Fiz"\
1<oan?*/!?%5$\!?%3;?)*aa::::::+
o"Buzz"/$0oo

Try it online!
Prints a trailing newline
How it works
0v...
.<... Initialises the stack with 0
.....

.....
1<................;?)*aa::::::+ Increment the counter and duplicate it a looooot
.....                           End the program if the counter is larger than 100 (10*10)

0..oo:oo"Fiz"\
.............\!?%3... Check if the counter is divisible by 3 and print Fizz if so
.....                 Also push a 0 to the stack

.......o         Swap the pushed 0 if it exists (otherwise it swaps two copies of the counter)
......./!?%5$... Check if the counter is divisible by 5 and print Buzz if so
o"Buzz"/$0oo     Also push a 0 to the stack

.......... Multiply the top two values of the stack.
..oan?*... If the counter was divisible by 5 or 3 print the number
.......... Print a newline and loop around again

As time goes, the stack fills up, with an extra copy of the counter for each Fizz or Buzz (and two for FizzBuzzes). This is due to the extra copy(s) of the counter that don't end up being printed.

sed, 275 272 270 260 254 249 245 bytes
s/.*/t0u123456789/
:1
s/(tu?(.).*)/\1\n\2/
s/u(.)(t?)(.*)/\1\2u\3\1/
/9u/{s/t(.)/\1t/;s/u//;s/^/u/}
/99/!b1
s/$/\n10/
s/[0-9][05]/&Buzz/g
s/[0369]{2}/&Fizz/g
s/[147][258]/&Fizz/g
s/[258][147]/&Fizz/g
s/[0-9]+([FB])/\1/g
s/\n0/\n/g
s/[^\n]+\n//
q

Try it Online
This is a pure sed script which discards all input, if any, and then prints all the necessary output lines and quits.
Explanation
The script is divided into a sequence of three main parts: 1. Numeral generation; 2. "Fizz/Buzz/FizzBuzz" insertion; and 3. Formatting.
1. Numeral generation (lines 1 through 6)
The purpose of this part is to generate 99 lines containing the base 10 numerals corresponding to numbers 1 through 99. For that, we first set the entire pattern space to the following string:
t0u123456789

We will call the above string our state string. Next, we enter a loop in which each iteration goes like this:

A newline is appended to the pattern space;
A copy of the first numeral character after the "t" in the state string is appended to the pattern space;
A copy of the first numeral character after the "u" in the state string is appended to the pattern space;
The "u" in the state string is moved from its current position to the immediate right of the first numeral character after it or, if a "t" is already in said position, the "u" is instead moved to the immediate right of that "t";
If the "u" in the state string is immediately at the right of the "9" in the state string, the "t" is moved from its current position to the immediate right of the first character after it, and the "u" is moved from its current position to the immediate left of the "0" in the state string;
If there isn't a "99" anywhere in the pattern space (i.e., the loop has not finished its job of generating all the 99 lines), control goes back to line 2 (label :1) and so this enumeration of procedures is repeated from step 1; otherwise, control flow continues into the next line.

2. "Fizz/Buzz/FizzBuzz" insertion (lines 7 through 11)
The purpose of this part is to append "Fizz" immediately after each two-digit numeral in the pattern space which corresponds to a number which is a multiple of 3 but not of 5; to append "Buzz" immediately after each two-digit numeral in the pattern space which corresponds to a number which is a multiple of 5 but not of 3; and to append "FizzBuzz" after each two-digit numeral in the pattern space which corresponds to a number which is a multiple of both 3 and 5. This is how the computations go:

We append a newline followed by "10" to the pattern space.
Next, we search for all substrings of the pattern space formed by a digit between 0-9 on the left and either a 0 or a 5 on the right. We insert "Buzz" into the pattern space immediately after each such substring;
Finally, we insert "Fizz" into the pattern space immediately after each substring which matches either of the following criteria:

Substrings formed by two digits which may be 0, 3, 6, or 9;
Substrings formed by a digit which is either 1, 4 or 7 on the left and a digit which is either 2, 5 or 8 on the right;
Substrings formed by a digit which is either 2, 5 or 8 on the left and a digit which is either 1, 4 or 7 on the right.

3. Formatting (lines 12 through 15)
This part is straight forward. Here we remove all of the following substrings from the pattern space:

Every contiguous sequence of numeral characters on the immediate left of a "F" or a "B";
All 0's on the immediate right of a newline character;
All characters from the beginning of the pattern space up to and including the first newline character (remember that the state string is still there and there's a newline immediately before the first output numeral).

And then sed just prints the final contents of the pattern space and calls it quits.

Brain-Flak, 474 470 446 438 420 412 bytes
-18 bytes thanks to Nitroden!
-8 thanks to Wheat Wizard
(((()()()()()){}){}){({}[(()())]((((())))))}{}{({}<>)<>({}<>)<>({}()()<>)<>}<>{}{}{([{}]())({()<(({}())()){(<{}>)((((()()()())())((((({}{}){})[()]){}){}()))){({}<>)<>}}{}{(<{}>)(((((()()()())({})){}())(({})({}())({}{})))){({}<>)<>}}>}{}[()]){([](<>))<>((()()()()()){}){(({}<({}())>)){({}[()])<>}{}}{}<>([{}()]{}<>)<>{({}<>)(<>)}}{}(<>)<>}<>{}{{({}((((()()()){}){}){}){}<>)<>}({}(()()()()()){}<>)<>}<>{({}<>)<>}<>

Try it online!
Gosh, it's nice to finally check this off my to-do list.
Explanation:
Brain-Flak is obviously not very good at getting the modulo of numbers, so I bypassed this by pushing all the elements first.
(((()()()()()){}){}) Push 20
{ Loop 20 times
    ({}
    [(()())]    Push a 2 to represent a Buzz
    ((((()))))  Push 4 1s
    ) And decrement loop counter
}{} Pop the excess 0
{ Loop over the list of numbers
    ({}<>)<>({}<>)<> Transfer two of the elements to the other stack
    ({}()()<>)<>     And add 2 to the last one
}<>{}{} Pop the excess two elements

Now 1 represents normal numbers, 2 represents Buzz, 3 is Fizz and 4 represents FizzBuzz. Initially I just pushed the values that repeat every 15 numbers 7 times and popped the excess 5, but this way turned out to be slightly shorter.
{ Loop over each element
    ([{}]()) Subtract one from the current element
    ({ Fizz and/or Buzz if num is not 1
        <(({}())())  Subtract 1 and push, twice
        { Push Buzz if num was not 3
            (<{}>)((((()()()())())((((({}{}){})[()]){}){}()))){({}<>)<>}
        }{}
        { Push Fizz if num is not 2
            (<{}>)(((((()()()())({})){}())(({})({}())({}{})))){({}<>)<>}
        }
        >
        ()
    }{}[()]) Push -1 if neither Fizz nor Buzz were pushed
    {
        ([](<>)) Push length of list to other stack
        <>((()()()()()){}) Push 10 as the mod
        Div/mod algorithm
        {(({}<({}())>)){({}[()])<>}{}}{}<>([{}()]{}<>)<>
        Pushes n%10 to output stack and n/10 to the list stack
        { If div is not 0
            ({}<>) Push it to the other stack
            (<>)   Push 0
        }
    }{} Pop excess 0
    (<>)<> Push 0 to other stack to represent a newline
}<>{} Pop extra newline
{ Loop over values
    {
        ({}((((()()()){}){}){}){}<>)<>  Add 48 to every value
    }
    ({}(()()()()()){}<>)<> Turn 0s into newlines
}  Until there's two 0s in a row
<>{({}<>)<>}<> Reverse output

Fizz in 44 bytes

Buzz in 44 bytes

APL (Dyalog Unicode), 37 bytesSBCS
↑{∨/d←4/0=3 5|⍵:d/'FizzBuzz'⋄⍕⍵}¨⍳100

Try it online!
⍳100 ɩndices 1…100
{…}¨ apply the following anonymous lambda to each of those:
 ⍵ the argument; e.g. 20
 3 5| the division remainder when that is divided by 3 and 5; e.g. [2,0]
 0= Boolean mask where that is equal to 0; e.g. [0,1]
 4/ replicate those numbers for 4 copies of each; e.g. [0,0,0,0,1,1,1,1]
 d← assign that to d
 ∨/…: if any of those are true (OR-reduction); e.g. true:
  d/'FizzBuzz' use d to mask the characters of the string; e.g. "Buzz"
 ⋄ else:
 ⍕⍵ stringify the argument; e.g. "20"
↑ mix the list of strings into a matrix, so it prints right

Art

@AndrewOgden Thank you!

Rattle, 54 44 bytes
Fizz&Buzz|!I=[g+bs%3[0b0b^0]g%5[0b1b^0]B]100

Try it Online!
This [was] my first answer in my new programming language! (This answer has since been golfed, and works on my new online interpreter)
Eventually, this programming language might have a more concise way to solve this challenge.
^this ended up being true - after a couple updates, 10 bytes can be shaved off the original answer (without implementing trivial built-ins)
Explanation
Fizz&Buzz         a variable containing the text Fizz and Buzz
|                 signals the end of the input
!                 is a flag to disable implicit printing at EOF
I                 splits the variable into parts and stores it in consecutive memory slots
=                 sets top of stack to 0
[                 start outer loop
g+bs              gets value at slot 3 (starts at zero), increments, appends it to a buffer, saves it to slot 3
%3                takes the current value on stack and pushes the value mod 3 to stack
[0b0b^0]          if the value on stack is equal to 0, concatenates value from memory slot 0 ("Fizz") to a buffer and nullifies the 0th element of the buffer
g%5               pushes value from slot 3 to stack, takes the value and pushes the value mod 5 to stack
[0b1b^0]          if the value on stack is equal to 0, concatenates the value from memory slot 1 ("Buzz") to the buffer and nullifies the 0th element of the buffer if not null already
B                 if the buffer is non-empty, prints buffer
]100              end outer loop - repeats 100 times

Spaghetti, 522 bytes
main:0"n"goto store goto l l:100"n"goto retrieve goto areEqual"EOF"goto jumpIfTrue"n"goto retrieve 1 2 goto add"n"goto store 15"n"goto retrieve 2 goto modulus 0 goto areEqual"f"goto jumpIfTrue 3"n"goto retrieve 2 goto modulus 0 goto areNotEqual"b"goto jumpIfTrue"Fizz"1 goto print goto b t:3"n"goto retrieve 2 goto modulus 0 goto areEqual"l"goto jumpIfTrue"n"goto retrieve 1 goto print goto l b:5"n"goto retrieve 2 goto modulus 0 goto areNotEqual"t"goto jumpIfTrue"Buzz"1 goto print goto l f:"FizzBuzz"1 goto print goto l

Requires a newline at the end, cause otherwise the interpreter throws a hissy fit.
Spaghetti is a stack based language that promotes using goto extensively. That means, every single operation you use requires a goto statement along with it.
That being said, this took a while.
Commented version is at the Spaghetti examples.
Try it on the online interpreter! (Code must be pasted in)

LolCode, 392 383 353 bytes
This LolCode follows the 1.3 standard used by the lci interpreter.
Unfortunately, no online interpreter.
Not the best language to golf with, but it's fun!
Update 1: changed for loop to while loop
Update 2: removed newlines in favor of commas (soft command break)
HAI 1.3,CAN HAS STDIO?,I HAS A v ITZ 1,IM IN YR s,BOTH SAEM 0 AN MOD OF v AN 15,O RLY?,YA RLY,VISIBLE "FizzBuzz",NO WAI,BOTH SAEM 0 AN MOD OF v AN 3,O RLY?,YA RLY,VISIBLE "Fizz",NO WAI,BOTH SAEM 0 AN MOD OF v AN 5,O RLY?,YA RLY,VISIBLE "Buzz",NO WAI,VISIBLE v,OIC,OIC,OIC,BOTH SAEM v AN 100,O RLY?,YA RLY,GTFO,OIC,v R SUM OF v AN 1,IM OUTTA YR s,KTHXBYE

Nice first post, welcome to the site!

Kakoune, 57 bytes
!seq 100
%s[05]$
Ab<esc>%s(\w+\n){3}
s\d+
cFizz<esc>%s\d*b
cBuzz

Explanation:
!seq 100               Call the external sh command `seq 100`, insert the output (numbers 1-100)
d                      ! inserts a trailing newline, delete it
 %s[05]$               Select all lines ending with 0 or 5, which is equivalent to being divisible by 5
Ab<esc>                Append a b to these lines, signifying that they should be buzzed later on
       %s(\d+b?\n){3}  Select every third line
s\d+              Select every third number (unselecting the b's)
cFizz<esc>             Replace with Fizz
          %s\d*b       Select (including 0) digits followed by a b
cBuzz                  Replace with Buzz

Welcome back to CGCC!

GNU AWK, 1 input byte + 60 bytes = 61 bytes
An approach different from Cabbie407's, that golfed 2 bytes off thanks to the more flexible parsing of the GNU's implementation. Still needs one EOF input.
END{for(;++n<101;print i?i:n)i=(n%3?e:"Fizz")(n%5?e:"Buzz")}

Try it online!
END              # starts after commanding the EOF (Ctrl+D).
{
for(;
    ++n<101;     # the _n_ variable is started here on the conditional, at the value 1.
    print i?i:n  # in the end of each loop, prints _i_ if non-null, or _n_.
   )
      i=(n%3?e:"Fizz")(n%5?e:"Buzz")
      # two ternary conditionals that concatenates Fizz and Buzz accordingly.
      # by the way, _e_ is a not assigned variable, which will return a null string ("").
      # if n != 0 (mod 15), then _i_ will return null at the print statement above.
}

For no input, use the BEGIN pattern instead (62 bytes total):
BEGIN{for(;++n<101;print i?i:n)i=(n%3?e:"Fizz")(n%5?e:"Buzz")}

Java, 100 98 95 94 Bytes (only loop, full code is 136 bytes, see bottom)
for(int i=0;i++<100;){var s=i%3<1?"Fizz":"";s=i%5<1?s+"Buzz":s;System.out.println(s==""?i:s);}

Try it here. Probably could be a lot smaller. I just started to learn java a few days ago (although I do have experience in other languages), this is the best I can do.
Breakdown of how it works. Sorry if I get some terms wrong or explain stuff poorly:
for(int i=0;i++<100;)

Just the loop - starts at 1 goes to 100:
{var s=i%3<1?"Fizz":"";

Making a variable called "s", equal to a value, if "i" is divisible by 3 with a remainder of less than 1 (1 character/byte smaller than checking ==0), set "s" equal to "buzz". If it isn't, set it equal to "".
s=i%5<1?s+"Buzz":s;

Set s equal to a value: if i is divisible by 5 with a remainder of less than 1, set s equal to s + "buzz", if it isn't, set it equal to itself.
System.out.println(s==""?i:s);}

System.out.println is just a simple print statement. Inside it, check if s is equal to "" (if s wasn't divisible by 3 or 5, it would be "") print i (the number), otherwise print s.
Feedback is greatly appreciated.
Edit: 94 bytes for just the loop, below is what I think the full script would be, 136 bytes : (
interface f{static void main(String[]a){for(int i=0;i++<100;){var s=i%3<1?"Fizz":"";s=i%5<1?s+"Buzz":s;System.out.println(s==""?i:s);}}}

Welcome to Code Golf, nice first answer! You may want to check out Tips for golfing in Java.

Perl 5 (ppencode-compatible), 1232 690 bytes
Today I learned that and has higher precidence than or or xor; I suffered from making a proper control flow
eval q y eval q x ord or return cos while chop and chop and chop x and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y xor eval q y print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos if length q q s s q eq chr ord reverse length or not chr ord reverse length y or eval q x print length unless length q q s s q eq chr ord reverse length or not chr ord reverse length x xor print chr hex qw q and q while s qq q and length ne ord qw q eq

Try it online!
How it works
# fizz part
eval q y
   # if(length%3==0)
   eval q x
      # instead of length or return 1
      ord or return cos
   while
      # instead of s/...//
      chop and chop and chop
   x and

   # print 'Fizz'
   print chr ord uc qw q for q and
   print chr ord q tie gt and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and

   # for truthy
   return cos
for
   # instead of $_
   uc
y

xor

# buzz part
eval q y
   # print 'Buzz'
   print uc chr ord q dbmopen and and
   print chr ord q dump and and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and

   # for truthy
   return cos
if
   # instead of length%5, /[05]$/
   length q q s s q eq chr ord reverse length or
   not chr ord reverse length
y

or

# this block is done when length%15==0 or length%3&&length%5
eval q x
   print length
unless
   # instead of length%5
   length q q s s q eq chr ord reverse length or
   not chr ord reverse length
x

xor

# newline
print chr hex qw q and q

while
   s qq q and

   # ord qw q eq == 101
   length ne ord qw q eq

Previous
eval q y eval q kill and length or return cos while s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and s q qq and ok and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y or eval q y eval q kill and length or return cos while s q qq and s q qq and s q qq and s q qq and s q qq and ok and print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y or eval q y eval q kill and length or return cos while s q qq and s q qq and s q qq and ok and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc y or print length xor print chr length q q x x x x eq while s qq q and length ne ord qw q eq

Try it online!
Explained
# fizzbuzz part
eval q y
   # length%15==0?
   eval q k
         ill and length or return cos
      while
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and
s q qq and s q qq and s q qq and o
   k and
   # then print FizzBuzz, as in first ppencode
   print chr ord uc qw q for q and
   print chr ord q tie gt and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and
   print uc chr ord q dbmopen and and
   print chr ord q dump and and
   print chr length q else x oct oct ord q eq le and
   print chr length q else x oct oct ord q eq le and
   # cos is for TRUTHY
   return cos
 # don't change $_ outside
 for uc
# buzz part, like above
y or eval q y
   eval q kill and length or return cos while s q qq and s q qq and s q qq and s q qq and s q qq and ok and print uc chr ord q dbmopen and and print chr ord q dump and and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc
# fizz part, like above
y or eval q y
   eval q kill and length or return cos while s q qq and s q qq and s q qq and ok and print chr ord uc qw q for q and print chr ord q tie gt and print chr length q else x oct oct ord q eq le and print chr length q else x oct oct ord q eq le and return cos for uc
# no special strings
y or print length
# print LF
xor print chr length q q x x x x eq
# pretty familiar, isn't it?
while s qq q and length ne ord qw q eq

Quipu, 101 bytes
1&0&'F0&'B1&\n
++[]'i[]'u[]/\
1%3&'z5&'z6&0&
1&%%'z%%'z==??
%%3&/\5&/\0&
1&>>  >>6&[]
>>      ??/\
::

Try it online!
Ungolfed:
" 0  1  2  3  4  5  6"
"--------------------"
 1& 0& 'F 0& 'B 1& \n
 ++ [] 'i [] 'u [] /\
 1% 3& 'z 5& 'z 6& 0&
 1& %% 'z %% 'z == ??
 %% 3& /\ 5& /\ 0&
 1& >>    >> 6& []
 >>          ?? /\
 ::

Thread 0 increments the accumulator (acc) every iteration, stopping execution if acc == 101, then jumps to thread 1.
Thread 1 checks if (acc % 3) > 0. If so, it jumps to thread 3, otherwise it jumps to thread 2.
Thread 2 prints Fizz, then jumps to thread 3.
Thread 3 checks if (acc % 5) > 0. If so, it jumps to thread 5, otherwise it jumps to thread 4.
Thread 4 prints Buzz, then jumps to thread 6.
Thread 5 looks back to thread 1 to see if (acc % 3) == 0. If so, it jumps to thread 6, otherwise it prints acc, then jumps to thread 6.
Thread 6 prints a newline, then jumps back to thread 0.
I think this could probably be refactored to golf away some of the whitespace, but I'm not doing that since if I do, I'll likely get sucked in and do nothing else for ~8 hours or so. :/

Two less whitespace by adding four more threads. I gave this a go before looking at your answer and ended up at 102 bytes through a different method

Fact, 11 bytes (SBCS)
ef̀|3 5^ŹFh̃õ

Explanation
e            1e2 (i.e. 100)
 f̀           for i in 1:100
  |3 5           Divisibility by [3, 5] (vectorizes)
      ^          String repeat by (vectorizes):
       ŹF            "FizzBuzz"
         h̃           Halved (i.e. ["Fizz", "Buzz"])
          õ      Logical OR with i
                 (in Fact, lists are false when all items are "" or 0
                  or when the list is empty)
Implicit grid (smash inner lists and join outer list by newline)

Fork and test
Fact, 15 bytes
ef̀|3 5^'b̀M̀b̀Ò'h̃õ

No "FizzBuzz" builtin, simply uses string compression

Welcome back old friend!

Welcome to Code Golf, new user! winks

Thank you. :) Hate to say that, but this is going to be my last post before a 4-month hiatus. I'll return as soon as possible

Python, 108 102 bytes
Thanks to caird coinheringaahing for -6 bytes!
for x in range(1,101):
    y=""
    if x%3<1:y="Fizz"
    if x%5<1:y+="Buzz"
    y=y or x
    print(y)

You can use <1 instead of ==0 for -1 byte, and instead of if y=="":y=x", you can do y=y or x. Also, this just outputs the numbers from 1 to 100: Try it online! This is 82 bytes

Crystal, 114 bytes
1.upto(100)do|n|case when n%15==0;puts "FizzBuzz"when n%5==0;puts "Buzz"when n%3==0;puts "Fizz"else puts n end end

Try it online!
How it works:
First, it tells it to repeat the code 100 times, with the iteration as n.
If n mod 15 = 0, then output FizzBuzz.

If n mod 5 = 0, then output Buzz.

If n mod 3 = 0, then output Fizz.
If none of those are true, just output the iteration, n.

Welcome to Code Golf, and nice answer!

Kustom, 72 bytes
This somehow gets a decent score for what it is?
I'm not sure if this language even has an official name, but it's used in a few Android customization apps (KLWP, KWGT, and KLCK).
Kustom function documentation for those curious
$fl(1,100,"i+1","if(i%3=0&i%5=0,FizzBuzz,i%3=0,Fizz,i%5=0,Buzz,i)","
")$

and a bit more readable:
$fl(
    1,
    100,
    "i+1",
    "if(
        i%3 = 0 & i%5 = 0,
        FizzBuzz,
        i%3 = 0,
        Fizz,
        i%5 = 0,
        Buzz,
        i
    )",
    "
"
)$

Welcome to Code Golf, and nice answer!

Julia 59 char, 59 bytes
Below works in the Julia REPL
(x->(t="Fizz"^(x%3<1)*"Buzz"^(x%5<1);t>"" ? t : x)).(1:100)
an alternative solution of same char/byte length in Julia REPL is
(x->(s=x%3<1;t=x%5<1;(x,"Fizz"^s*"Buzz"^t)[s|t+1])).(1:100)
In search of the 59 char/59 bytes solution which includes a print statement.

Welcome to Code Golf, and nice answer!

This only prints in the repl. You can either specify Julia REPL, or add a print

Thunno 2 N, 11 bytes
ɦık+Ḋkg×Jn|

Attempt This Online!
Add a trailing £ if you want it flagless.
Thunno 2, 18 17 bytes
ɦı35dḊʋ⁴ȥæÞ½×Jn|£

Attempt This Online!
No questionable constants.
Explanation
ɦık+Ḋkg×Jn|  # Full program
ɦ            # Push 100
 ı           # Map over [1..100]:
  k+         #  Push [3, 5]
    Ḋ        #  Divisible by [3, 5] (vectorises)
     kg      #  Push ["Fizz", "Buzz"]
       ×     #  Multiply element-wise
        J    #  Join by nothing
         n|  #  Logical OR with the number
             # N flag joins by newlines
             # Implicit output

ɦı35dḊʋ⁴ȥæÞ½×Jn|£  # Full program
ɦ                  # Push 100
 ı                 # Map over [1..100]:
  35d              #  Push [3, 5]
     Ḋ             #  Divisible by [3, 5] (vectorises)
      ʋ⁴ȥæÞ        #  Push compressed string "FizzBuzz"
           ½       #  Split in half to get ["Fizz", "Buzz"]
            ×      #  Multiply element-wise
             J     #  Join by nothing
              n|   #  Logical OR with the number
                £  #  Print the result

Mouse, 75 bytes
1I:(I.101<^0J:I.3\0=["Fizz"J.1+J:]I.5\0=["Buzz"J.1+J:]J.0=[I.!]"!"I.1+I:)$

Ungolfed:
1 I:               ~ Start a loop index at 1
( I. 101 < ^       ~ While I < 101...
  0 J:             ~ Begin a divisibility indicator at 0
  I. 3 \ 0 = [     ~ If I % 3 == 0
    "Fizz"         ~ Print "Fizz" to STDOUT
    J. 1 + J:      ~ Increment J
  ]
  I. 5 \ 0 = [     ~ If I % 5 == 0
    "Buzz"         ~ Print "Buzz" to STDOUT
    J. 1 + J:      ~ Increment J
  ]
  J. 0 = [         ~ If neither 3 nor 5 divides I
    I. !           ~ Print I to STDOUT
  ]
  "!"              ~ Print a newline
  I. 1 + I:        ~ Increment I
)
$

I'm gonna upvote if you add a cat-program.

@flawr You should submit your own cat program. It will be a game of cat and mouse.

@flawr Not quite cat, but I did add a zcat program.

Processing, 74 bytes
This is based on the Java answer by Geobits. I converted it into Processing and since Processing is similar to Java, the code is a lot similar to Geobits'.
for(int i=0;i++<100;)println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));

Ah, Processing. Java's willful son, stubbornly insisting that he's going to grow up to be an artist :D

Windows Batch, 149 bytes
@for /l %%N in (1 1 100)do @(set s=&set/a1/(%%N%%3^)||set s=Fizz&set/a1/(%%N%%5^)&&(if defined s (echo Fizz)else echo %%N)||call echo %%s%%Buzz)2>nul

The SET /A statements test the modulo 3 and 5 without using IF by intentionally dividing by zero and using && and || conditional command concatenation. Of course stderr must be disabled, but it still saves bytes vs an IF statement.
Windows Batch (unusual cmd.exe configuration, and environment assumption), 166 165 133 bytes
My original answer used delayed expansion, but the code to enable delayed expansion  takes 32 bytes all on its own. However, some people have their cmd.exe configured to have delayed expansion enabled by default. For the small minority of people that configure cmd.exe this way, then the following is significantly shorter.
@for /l %%N in (1 1 100)do @(set 1=&set/a1/(%%N%%3^)||set 1=Fizz&set/a1/(%%N%%5^)||set 1=!1!Buzz&>nul set 1&&echo !1!||echo %%N)2>nul

Besides relying on an unusual cmd.exe configuration, it is also reliant on the absence of any environment variable names that begin with 1. This is normally safe because batch treats something like %1var% as batch parameter %1 followed by a string constant var - the trailing % would get stripped. So people are taught to never begin variable names with a digit.

Ruby, 82 72 70 68 bytes
based on other answers:
puts (1..100).map{|i|(x=(i%3<1?"Fizz":"")+(i%5<1?"Buzz":""))>""?x:i}

old solution:
(1..100).map{|i|$><<"Fizz"if f=i%3<1
$><<"Buzz"if b=i%5<1
$><<i if !(f||b)
puts()}

I posted a 50-byte solution.

PHP, 73 71 bytes
<?for($i=0;$i++<100;)echo$i%3?$i%5?$i:@Buzz:@Fizz.($i%5?"":@Buzz),"
";

All the most terrible things.  I wanted the wrongheaded ternary to do something magical, but it did not.

Common Lisp, 121
(dotimes(x 100)(flet((d(n)(= 0(mod(1+ x)n))))(princ(cond((d 15)"FizzBuzz")((d 3)"Fizz")((d 5)"Buzz")(t(1+ x)))))(terpri))

Readable:
(dotimes (x 100)
  (flet ((d (n) (= 0 (mod (1+ x) n))))
    (princ (cond ((d 15) "FizzBuzz")
                 ((d 3) "Fizz")
                 ((d 5) "Buzz")
                 (t (1+ x)))))
  (terpri))

Go, 130 129 134 bytes
package main;import."fmt";func main(){for i:=1;i<101;i++{o:="";if i%3<1{o+="Fizz"};if i%5<1{o+="Buzz"};if o==""{Print(i)};Println(o)}}

I wish i had ternary operators...
Edit:
@Dust pointed out that I printed to stderr so my solution actually increased in size :(
Try it online!

Ruby, 59
I wanted to make a Ruby version using the slick modulo/integer-division/string-multiplication trick from feersum's Python answer (though unfortunately Ruby doesn't handle string multiplication the same way, so I spent some bytes on that):
100.times{|i|puts "#{i+1}\r"+"Fizz"*(i%3/2)+"Buzz"*(i%5/4)}

Note that this uses a carriage return \r without a newline. I don't know how portable this is; it works on my Linux and should work on Linux in general, as well as on Mac, but I'm not sure how Windows handles it. Without that, here's a 61-byte version:
100.times{|i|puts ("Fizz"*(i%3/2)+"Buzz"*(i%5/4))[/.+/]||i+1}

You don't need space after puts.

Your first answer always prints the number even when it should only print the string

As an amendment to my previous comment: The first answer may look visually correct on some terminals, the actual output still contains the number

Commodore Basic, 87 bytes
1F┌I=1TO100:F=F+1:B=B+1:IFF=3T|?"FIZZ";:F=0
2IFB=5T|?"BUZZ";:B=0
3IFF>0A/B>0T|?I;
4?:N─

Or in "shifted mode" to get both lower- and upper-case letters, but with the byte values of lowercase and uppercase swapped relative to ASCII-1967 (press COMMODORE+SHIFT):
1fOi=1to100:f=f+1:b=b+1:iff=3tH?"Fizz";:f=0
2ifb=5tH?"Buzz";:b=0
3iff>0aNb>0tH?i;
4?:nE

Usual PETSCII-to-Unicode substitutions: ┌ = SHIFT+O, | = SHIFT+H, / = SHIFT+N, ─ = SHIFT+E
Commodore Basic doesn't have a "modulus" operation, so I need to use alternate methods to figure out when to print what: keeping a pair of counters turns out to be fewer bytes than dividing and checking for integer-ness.  It also doesn't have a true logical "and" (despite the manual saying otherwise), so I need to do an explicit comparison against zero to decide if I should print the plain number.

@DLosc, you can switch into "shifted mode" which gives access to both upper- and lower-case, but with the character positions reversed relative to the ASCII-1967 which people are familiar with (eg. character #65 is lowercase "a" rather than uppercase).

Gol><>, 40 bytes
`e2RFL5%zR"zzuB"L3%zR"zziF"lQlRoaoC|LN|;

Updated for 0.4.0! I'm still tinkering with loops and trying to figure out how to do things best, but this is looking good so far.
Try it online.
Explanation
`e            Push 'e', or 101
2RF ... |     Execute F for loop twice - the first time activates the loop, and the
              second time updates it. This effectively makes the loop start from 1
L5%z          Push 1 if loop counter % 5 is 0, else 1
R"zzuB"       Push "Buzz" (top of stack) number of times
L3%z          Push 1 if loop counter % 3 is 0, else 1
R"zziF"       Push "Fizz" (top of stack) number of times
lQ ... |      If the stack is not empty...
  lRo         Output stack
  ao          Output newline
  C           Continue for loop
LN            Otherwise, print loop counter with newline

;             Terminate program

As we can see, there's a lot of abuse of R, which pops the top of the stack and executes the next instruction that many times.

That's a smart idea! Mind if I use it?

Dart, 88
main({i=0}){while(i<100)print(["FizzBuzz","Fizz","Buzz",++i][(i%3).sign*2+(i%5).sign]);}

Dart is somewhat hampered in the golfing by not having conversion between bool and int, but the sign getter on integers helps a little.

F#, 129 116 113 111
Seq.iter(fun x->printfn"%s"(["Fizz";"";""].[x%3]+(if x%5=0 then"Buzz"elif x%3>0 then string x else""))){1..100}

Jolf, 42 33 31 bytes
Try it here! Replace ƒ with \x9f. I'm stealing ETHproduction's method of fizzbuzzing.
ƒΜz~1d|]"FizzBuzz"?%H340?%H548H

Old version, 42 bytes
γ"Fizz"ƒΜz~1d?mτͺ35H+γζ?m|3Hγ?m|5HΖ"Buzz"H
γ"Fizz"                                     γ = "Fizz"
        Μz~1d                               map 1..100 with the following function
             ?mτͺ35H                        if both 3 and 5 | H
                    +γζ                      return γ + ζ
                       m|3H                 else if 3 | H
                           γ                 return γ
                             ?m|5H          else if 5 | H
                                  Ζ"Buzz"    return ζ = "Buzz"
                                         H  else return H
       ƒ                                    join by newlines

I might be able to golf it down by using the dictionary in Jolf, but who would want to with such a perfect score?

D, 130 bytes
import std.stdio,std.conv;void main(){string x;for(int i;i++<100;x=((i%3?"":"Fizz")~(i%5?"":"Buzz")),writeln(x?x:i.to!string)){};}

Ungolfed:
module FizzBuzz;

import std.stdio;
import std.conv;

void main() {
  string x;
  for (
    int i;
    i++ < 100;
    x = ((i % 3 ? "" : "Fizz")
      ~ (i % 5 ? "" : "Buzz")),
    writeln(x ? x : i.to!string)
  ){};
}

Or, building a string, for 142 bytes,
import std.stdio,std.conv;void main(){string x,y;for(int i;i++<100;x=((i%3?"":"Fizz")~(i%5?"":"Buzz")),y~=(x?x:i.to!string)~"\n"){};write(y);}

Ungolfed:
module FizzBuzz;

import std.stdio;
import std.conv;

void main() {
  string x,y;
  for (
    int i;
    i++ < 100;
    x = ((i % 3 ? "" : "Fizz")
      ~ (i % 5 ? "" : "Buzz")),
    y ~= (x ? x : i.to!string) ~ "\n"
  ){};
  write(y);
}

Hoon, 126 bytes
%+
turn
(gulf [1 100])
|=
a/@
=+
[=((mod a 3) 0) =((mod a 5) 0)]
"{?:(-< "Fizz" "")}{?:(-> "Buzz" "")}{?:(=(- [| |])  "")}"

Map over the list [1...100] with the function, interpolating the strings "Fizz" and "Buzz". If both mods are false, then it also interpolates the number.
This uses the fact that =+ pushes the value to the top of the context, which you can access with - and navigate with -< or -> for head/tail. Unfortunately, it looks pretty ugly because it needs a newline after runes to minimize byte count, along with not having built in operator functions.
I'm not entirely sure if this counts as a valid entry: It simply returns a list of strings to be printed by the shell, which is optimal. The other way would be to use ~& to print each element as it's mapped over, but it would still be rendered as "Fizz" or "Buzz" (with quotes) since it's a typed print, along with the shell then printing out the entire list anyways since it's the return value.

Vim, 66, 57 56 keystrokes
i1<esc>qqYp<C-a>q98@q3Gqy:s/\d*/Fizz<CR>3j@yq@y5Gqz:s<CR>ABuzz<esc>5j@zq@z

Further golfing, and explanation on the way.

A bit too late, but apparently this doesn't output correctly: Try it online!

Javascript, 56 bytes
for(f=0;f++<100;alert(f%5?b||f:b+'Buzz'))b=f%3?'':'Fizz'

Assuming 100 alerts is an acceptable output method.

Nice answer, but it's already been posted (That one originally used alert as well, but it was changed to console.log because all the other JS answers do the same)

AppleScript, 104 102 100 bytes
""
repeat with i from 1to 100
result&{"FizzBuzz",i,"Fizz","Buzz"}'s item((i^4mod 15+7)div 4)&"
"
end

If you run it in Script Editor, the result has "quotes" around it. If you run it with osascript, there are no "quotes", but the result ends with an extra blank line.
I steal the technique from Lynn's Lua answer, where the script picks from a list of possible values to print.  I use (i^4mod 15+7)div 4 to calculate the index 1, 2, 3, or 4.  It's different from Lua's i^2%3+i^4%5*2+1.
In AppleScript, i^4 raises i to 4th power.  It returns a real, which is a floating-point number, but the value is equal to the correct integer.
The values of n = i^4mod 15 with i from 1 to 15 are
i = 1   2   3   4   5   6   7   8   9  10  11  12  13  14  15
n = 1   1   6   1  10   6   1   1   6  10   1   6   1   1   0

So n is 0.0 for "FizzBuzz", 1.0 for i, 6.0 for "Fizz", or 10.0 for "Buzz". This pattern continues with i from 16 to 100. I need to map the values 0.0, 1.0, 6.0, 10.0 to a list index; lists in AppleScript start at index 1.
n          = 0.0   1.0   6.0  10.0
(n+2)mod 7 = 2.0   3.0   1.0   5.0
(n+7)div 4 = 1     2     3     4

My 104-byte answer used (n+2)mod 7, but that mapping had 5.0 instead of 4.0, so it needed a list of 5 items, where the extra item 0, cost 2 bytes.  My 102-byte answer uses (n+7)div 4.  My 100-byte answer deletes 2 extra spaces.

SNOBOL4 (CSNOBOL4), 137 121 114 bytes
I	X =X + 1
	O =EQ(REMDR(X,3)) 'Fizz'
	O =O EQ(REMDR(X,5)) 'Buzz'
	O =IDENT(O) X
	OUTPUT =O
	O =LT(X,100) :S(I)
END

Try it online!
Explanation:
					;* uninitialized variables start as ''
					;* which is coerced to 0 in computations
I	X =X + 1			;* Increment X
	O =EQ(REMDR(X,3)) 'Fizz'	;* if X mod 3 == 0, O = 'Fizz'
	O =O EQ(REMDR(X,5)) 'Buzz'	;* if X mod 5 == 0, concatenate O and 'Buzz'
	O =IDENT(O) X			;* if O is IDENTical to the empty string,
					;* set O to X
	OUTPUT =O			;* print O
	O =LT(X,100) :S(I)		;* set O to '' and if X < 100, goto I
END

Forth, 107 101 98 bytes
: f 101 1 do i 5 mod i 3 mod if dup if i . then else ." Fizz" then 0= if ." Buzz" then cr loop ; f

Ungolfed + close Python equivalent:
: f              \ def f():
  101 1 do       \     for i in range(1, 101):
    i 5 mod      \         a = i % 5  # Not an actual variable, pushed onto the stack
    i 3 mod      \         b = i % 3
    if           \         if b:      # b is popped
      dup        \             c = a
      if         \             if c:
        i .      \                 print(i, end='')
      then
    else         \         else:
      ." Fizz"   \             print('Fizz', end='')
    then
    0=           \         a = (a == 0)
    if           \         if a:
      ." Buzz"   \             print('Buzz', end='')
    then
    cr           \         print()
  loop
;
f                \ f()

Run it!

To Taylor Scott: sorry for deleting the edit. I thought adding another language would be more meaningful

Alex, while this is definitely a more interesting answer you should feel free to leave multiple responses to challenges.

12-BASIC, 73 55 50 bytes
FOR I=1TO 100?"FIZZ"*!(I%3)+"BUZZ"*!(I%5)OR I
NEXT

The first code golf program I've written in the language I'm creating.
I should probably avoid code golf while working on it though...

C#, 119 bytes
class q{static void Main(){for(var i=0;i++<100;)System.Console.WriteLine(i%3*i%5>0?i+"":$"{i%3:;;Fizz}{i%5:;;Buzz}");}}

Try it online!

I was wondering how close I could get to the long standing 124 byte C# answer by Pierre-Luc, so I challenged myself to try. After unexpectedly beating it by just one byte (123 bytes, Try it online!), I took the advice from @LiamK's three year old comment and used string interpolation to shave off another 4 bytes. I'm genuinely surprised by how well this worked out!

K (oK), 49 46 43 bytes
Solution:
`0:{$[a:,/$&`Fizz`Buzz!~5 3!'x;a;x]}'1+!100

Try it online!
Explanation:
`0:{$[a:,/$&`Fizz`Buzz!~5 3!'x;a;x]}'1+!100 / the solution
                                       !100 / range 0..99
                                     1+     / add 1
   {                               }'       / apply lambda {} to each number
    $[                        ; ; ]         / conditional, $[if;then;else]
                        5 3!'x              / apply modulo (!) of each 5 and 3 to the input x
                       ~                    / not (0->1, anything else->0)
            `Fizz`Buzz!                     / turn results into a dictionary
           &                                / keys where true
          $                                 / convert to strings
        ,/                                  / flatten
      a:                                    / save as a
                               a            / result if a is not empty - so Fizz / Buzz
                                 x          / result if a is empty - so 1, 2, 4
`0:                                         / print to stdout

Notes:

-6 bytes thanks to @ngn with a new approach

2 2/ -> 2/, @' -> '

it produces the same output without the $

\Fizz`Buzz`FizzBuzz->a,,,/$a:`Fizz`Buzz`

and here's a slightly shorter one abusing "where" on dicts: \0:{$[a:,/$&`Fizz`Buzz!~5 3!'x;a;x]}'1+!100`

Julia 1.0, 72 bytes
(n->println([n,"Fizz","Buzz","FizzBuzz"][sum(n.%[1,3,5,5].<1)])).(1:100)

Not the shortest solution possible, but I like the obfuscation. Try it online!
Explanation
We apply an anonymous function (n->...) itemwise .( ) to the range 1:100.
The function body does this (using sample input n=5):
n.%[1,3,5,5]          # Modulo n by each of these numbers                     [0,2,0,0]
.<1                   # Itemwise, is each remainder zero?                     [true,false,true,true]
sum(  )               # Count number of trues in the array                    3
                      # This will be 4 for multiples of 15, 3 for multiples
                      # of 5, 2 for multiples of 3, and 1 for other numbers
[n,"F","B","FB"][  ]  # Index (1-based) into this array                       "Buzz"
println(  )           # Print, with a newline

Javascript, 80 bytes
for(i=1;i<101;i++){console.log(i%3==0?i%5==0?"FizzBuzz":"Fizz":i%5==0?"Buzz":i)}

To whoever downvoted this; you really should explain why. Especially considering Jey is a new contributor.

Java 8, 129 bytes
interface I{static void main(String[]s){for(int i=0;++i<101;)System.out.println(i%15<1?"FizzBuzz":i%3<1?"Fizz":i%5<1?"Buzz":i);}}

Try it online

Zsh, 105 78 68 66 61 bytes
Try it online!
for i ({1..100})(((i%3))||w=Fizz;((i%5))||w+=Buzz;<<<${w-$i})

-27 using simpler approach
-10 using parameter fallback
-2 thanks to @Dennis - kudos for the bash solution
-5 thanks to @GammaFunction

Original solution, using weird r flag... try it online
for ((;i++<100;));{f=$[i%3>0?0:4] b=$[i%5>0?0:4]
echo ${(r:$f::Fizz:)}${(r:$b::Buzz:)}`((f+b>0))||<<<$i`}

You don't need the last ; on the first line. A port to Bash takes 70 bytes, thus beating my answer.

Also, you don't need the newline before the last } (which is missing in your answer). Try it online!

the bash solution still wins for originality.. I couldn't port that crazy for expression to zsh

61, mostly thanks to subshells

Julia, 87 bytes
z(i)=(f=i .%[3,5] .==0;sum(f)>0 ? foldl(*,["Fizz","Buzz"][f]) : i)
println.(z.(1:100))

Or we could kind of cheat to drop 3 bytes and use show instead of println.
Julia 83 bytes
z(i)=(f=i .%[3,5] .==0;sum(f)>0 ? foldl(*,["Fizz","Buzz"][f]) : i)
show(z.(1:100))

or a more legible FP style, poor performing, 91 bytes
F(x)=foldl(*,["Fizz","Buzz"][x .%[3,5] .==0])
N(y)=F(y)=="" ? y : F(y)
println.(N.(1:100))

Julia isn't really made for this, but I had fun thinking about this a bit :).

prod is better than foldr(*

Nice! I didn't think that'd work. Either way my solution is 10s of bytes away from the best Julia one :).

Sure. My score is here

Woah! How'd you do it? Or is that a secret? :) We have a thread that divulged into codegolf on julia discourse!

Sort of a secret. Although I have discussed julia golfing in a chat room on this site.

DIVSPL, 22 bytes
1..100
fizz=3
buzz=5

W n, 22 21 bytes
Seems like nobody ties with Dennis. Just 1 byte away...
♥:jΓƒ¢D╦Γ%%lOvhI♣BAE§

Uncompressed:
3m!?SY%?*?SZ%?a5m!*+a|2^N

Explanation
                      2^N For Each: 1 to 100
3m!                       Repeat whether current item is divisible by 3
   ?SY%?*                 Repeat that bool by the compressed "Fizz"
         ?SZ%?a5m!*       Do that for "Buzz" too
                   +      Join the results
                    a|    If the result is empty,
                          turn it to the current item value.

Flag: n                   Join the resulting list with newlines
                          Implicit output
```

Integral, 416 Bytes

⌡1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 17 Fizz 19 Buzz Fizz 22 23 Fizz Buzz 26 Fizz 28 29 FizzBuzz 31 32 Fizz 34 Buzz Fizz 37 38 Fizz Buzz 41 Fizz 43 44 FizzBuzz 46 47 Fizz 49 Buzz Fizz 52 53 Fizz Buzz 56 Fizz 58 59 FizzBuzz 61 62 Fizz 64 Buzz Fizz 67 68 Fizz Buzz 71 Fizz 73 74 FizzBuzz 76 77 Fizz 79 Buzz Fizz 82 83 Fizz Buzz 86 Fizz 88 89 FizzBuzz 91 92 Fizz 94 Buzz Fizz 97 98 Fizz Buzz⌡[j

Try it
Integral doesn't have very many ways of doing this challenge yet, so this'll have to do for now.
I'll update it once there's a better way.

ah, beautiful solution. what an algorithm.

Japt -R, 27 bytes
Finally came up with a shorter way!
Lõ@"FiBu"ò úz4 ËpXv°EÑÄÃ¬ªX

Test it
Lõ@"FiBu"ò úz4 ËpXv°EÑÄÃ¬ªX
L                               :100
 õ                              :Range [1,L]
  @                             :Map each X
   "FiBu"                       :  Literal string
         ò                      :  Partitions of length 2
           úz4                  :  Right pad each with "z" to length 4
               Ë                :  Map each element at 0-based index E
                p               :    Repeat
                 Xv             :      Test X for divisibility by (result will be 1 or 0)
                   °E           :        Prefix increment E
                     Ñ          :        Multiply by 2
                      Ä         :        Add 1
                       Ã        :  End map
                        ¬       :  Join
                         ªX     :  Logical OR with X
                                :Implicit output, joined with newlines

Python 3, 88 85 77 73 bytes
i=0
exec("i+=1;print(i%3*i%5and i or(i%3<1)*'Fizz'+(i%5<1)*'Buzz');"*100)

Try it online!

Welcome to the site, and nice first answer! Be sure to check out our Tips for golfing in Python page for more ways you could golf your answer.

Turing Machine Code, 5743 bytes
Should note that Turing Machine Code doesn't process newlines/carriage returns. So everything is necessarily on one line. Thus this may not be, by strict interpretation of the rules, a competing answer due to the nature of the language.

0 * * * 1
1 * 1 r #
# * # * f
f * * l f
f 1 1 l !
f 2 2 l "
f 3 3 l £
f 4 4 l $
f 5 5 l %
f 6 6 l ^
f 7 7 l &
f 8 8 l `
f 9 9 l (
f 0 0 l )
f F F l f
f i i l f
f z z l f
f B B l f
f u u l f
) 1 1 * ¬
) 2 2 * -
) 3 3 * =
) 4 4 * +
) 5 5 * {
) 6 6 * }
) 7 7 * [
) 8 8 * ]
) 9 9 * :
! _ _ r '
! 1 1 r @
! 2 2 * ~
! 3 3 r \
! 4 4 r /
! 5 5 * ,
! 6 6 r .
! 7 7 r <
! 8 8 * >
! 9 9 r ?
" _ _ r a
" 1 1 * b
" 2 2 r c
" 3 3 r d
" 4 4 * e
" 5 5 r ƒ
" 6 6 r g
" 7 7 * h
" 8 8 r ï
" 9 9 r j
£ _ _ r k
£ 1 1 r l
£ 2 2 r m
£ 3 3 * n
£ 4 4 r o
£ 5 5 r p
£ 6 6 * q
£ 7 7 r r
£ 8 8 r s
£ 9 9 * t
$ _ _ r ü
$ 1 1 r v
$ 2 2 * w
$ 3 3 r x
$ 4 4 r y
$ 5 5 * ž
$ 6 6 r A
$ 7 7 r Ɓ
$ 8 8 * C
$ 9 9 r D
% _ _ r E
% 1 1 * Ϝ
% 2 2 * G
% 3 3 * H
% 4 4 * I
% 5 5 * J
% 6 6 * K
% 7 7 * L
% 8 8 * M
% 9 9 * N
^ _ _ r O
^ 1 1 r P
^ 2 2 r Q
^ 3 3 * R
^ 4 4 r S
^ 5 5 r T
^ 6 6 * U
^ 7 7 r V
^ 8 8 r W
^ 9 9 * X
& _ _ r Y
& 1 1 r Z
& 2 2 * α
& 3 3 r β
& 4 4 r γ
& 5 5 * δ
& 6 6 r ε
& 7 7 r ζ
& 8 8 * η
& 9 9 r θ
` _ _ r ι
` 1 1 * κ
` 2 2 r λ
` 3 3 r μ
` 4 4 * ν
` 5 5 r ξ
` 6 6 r ο
` 7 7 * π
` 8 8 r ρ
` 9 9 r ς
( _ _ r σ
( 1 1 r τ
( 2 2 r υ
( 3 3 * φ
( 4 4 r χ
( 5 5 r ψ
( 6 6 * ω
( 7 7 r Α
( 8 8 r Β
( 9 9 * Γ
@ * * r @
@ # _ r Δ
Δ _ 1 r Ε
Ε _ 2 r F
' * * r '
' # _ r 2
2 _ 2 r #
~ * * r ~
~ 2 _ r ~
~ 1 _ r ~
~ # _ r Ζ
Ζ _ 2 r 2
\ * * r \
\ # _ r Η
Η _ 3 r 2
/ * * r /
/ # _ r Θ
Θ _ 4 r Ε
, * * r ,
, 5 _ r ,
, 1 _ r ,
, # _ r Ι
Ι _ 5 r 2
. * * r .
. # _ r Κ
Κ _ 6 r 2
< * * r <
< # _ r Λ
Λ _ 7 r Ε
> * * r >
> 8 _ r >
> 1 _ r >
> # _ r Μ
Μ _ 8 r 2
? * * r ?
? # _ r Ν
Ν _ 9 r 2
a * * r a
a # _ r Ξ
Ξ _ 3 r F
3 _ 3 r #
b * * r b
b 1 _ r b
b 2 _ r b
b # _ r Ο
Ο _ 1 r 3
c * * r c
c # _ r Π
Π _ 2 r 3
d * * r d
d # _ r Ρ
Ρ _ 3 r Ξ
e * * r e
e 4 _ r e
e 2 _ r e
e # _ r Σ
Σ _ 4 r 3
ƒ * * r ƒ
ƒ # _ r Τ
Τ _ 5 r 3
g * * r g
g # _ r Υ
Υ _ 6 r Ξ
h * * r h
h 7 _ r h
h 2 _ r h
h # _ r Φ
Φ _ 7 r 3
ï * * r ï
ï # _ r Χ
Χ _ 8 r 3
j * * r j
j # _ r Ψ
Ψ _ 9 r Ξ
k * * r k
k 3 _ r k
k # _ r 4
4 _ 4 r #
Ω _ 4 r F
l * * r l
l # _ r ¤
¤ _ 1 r 4
m * * r m
m # _ r ¥
¥ _ 2 r Ω
n * * r n
n 3 _ r n
n # _ r ¦
¦ _ 3 r 4
o * * r o
o # _ r ¨
¨ _ 4 r 4
p * * r p
p # _ r ©
© _ 5 r Ω
q * * r q
q 6 _ r q
q 3 _ r q
q # _ r ª
ª _ 6 r 4
r * * r r
r # _ r «
« _ 7 r 4
s * * r s
s # _ r ®
® _ 8 r Ω
t * * r t
t 9 _ r t
t 3 _ r t
t # _ r °
° _ 9 r 4
ü * * r ü
ü # _ r ±
± _ 5 r B
v * * r v
v # _ r ²
² _ 1 r ³
³ _ 5 r Ƒ
5 _ 5 r #
w * * r w
w 2 _ r w
w 4 _ r w
w # _ r ¶
¶ _ 2 r ±
x * * r x
x # _ r ·
· _ 3 r ±
y * * r y
y # _ r ¸
¸ _ 4 r ³
ž * * r ž
ž 5 _ r ž
ž 4 _ r ž
ž # _ r ¹
¹ _ 5 r ±
A * * r A
A # _ r »
» _ 6 r ±
Ɓ * * r Ɓ
Ɓ # _ r ¼
¼ _ 7 r ³
C * * r C
C 8 _ r C
C 4 _ r C
C # _ r ½
½ _ 8 r ±
D * * r D
D # _ r ¾
¾ _ 9 r ±
E * * r E
E # _ r ¿
E 5 _ r E
¿ _ 6 r F
6 _ 6 r #
Ϝ * * r Ϝ
Ϝ 1 _ r Ϝ
Ϝ 5 _ r Ϝ
Ϝ # _ r À
À _ 1 r 6
G * * r G
G 2 _ r G
G 5 _ r G
G # _ r Á
Á _ 2 r 6
H * * r H
H 3 _ r H
H 5 _ r H
H # _ r Â
Â _ 3 r ¿
I * * r I
I 4 _ r I
I 5 _ r I
I # _ r Ã
Ã _ 4 r 6
J * * r J
J 5 _ r J
J # _ r Ä
Ä _ 5 r 6
K * * r K
K 6 _ r K
K 5 _ r K
K # _ r Å
Å _ 6 r ¿
L * * r L
L 7 _ r L
L 5 _ r L
L # _ r Æ
Æ _ 7 r 6
M * * r M
M 8 _ r M
M 5 _ r M
M # _ r Ç
Ç _ 8 r 6
N * * r N
N 9 _ r N
N 5 _ r N
N # _ r È
È _ 9 r ¿
O * * r O
O 6 _ r O
O # _ r 7
7 _ 7 r #
É _ 7 r F
P * * r P
P # _ r Ê
Ê _ 1 r 7
Q * * r Q
Q # _ r Ë
Ë _ 2 r É
R * * r R
R 3 _ r R
R 6 _ r R
R # _ r Ì
Ì _ 3 r 7
S * * r S
S # _ r Í
Í _ 4 r 7
T * * r T
T # _ r Ï
Ï _ 5 r É
U * * r U
U 6 _ r U
U # _ r Ð
Ð _ 6 r 7
V * * r V
V # _ r Ñ
Ñ _ 7 r 7
W * * r W
W # _ r Ò
Ò _ 8 r É
X * * r X
X 9 _ r X
X 6 _ r X
X # _ r Ó
Ó _ 9 r 7
Y * * r Y
Y # _ r 8
8 _ 8 r #
Z * * r Z
Z # _ r Ô
Ô _ 1 r Õ
Õ _ 8 r F
α * * r α
α 2 _ r α
α 7 _ r α
α # _ r Ö
Ö _ 2 r 8
β * * r β
β # _ r ×
× _ 3 r 8
γ * * r γ
γ # _ r Ø
Ø _ 4 r Õ
δ * * r δ
δ 5 _ r δ
δ 7 _ r δ
δ # _ r Ù
Ù _ 5 r 8
ε * * r ε
ε # _ r Ú
Ú _ 6 r 8
ζ * * r ζ
ζ # _ r Û
Û _ 7 r Õ
η * * r η
η 8 _ r η
η 7 _ r η
η # _ r Ü
Ü _ 8 r 8
θ * * r θ
θ # _ r Ý
Ý _ 9 r 8
ι * * r ι
ι # _ r Ā
Ā _ 9 r F
9 _ 9 r #
κ * * r κ
κ 1 _ r κ
κ 8 _ r κ
κ # _ r Ă
Ă _ 1 r 9
λ * * r λ
λ # _ r Ą
Ą _ 2 r 9
μ * * r μ
μ # _ r Ć
Ć _ 3 r Ā
ν * * r ν
ν 4 _ r ν
ν 8 _ r ν
ν # _ r Ĉ
Ĉ _ 4 r 9
ξ * * r ξ
ξ # _ r Ċ
Ċ _ 5 r 9
ο * * r ο
ο # _ r Đ
Đ _ 6 r Ā
π * * r π
π 7 _ r π
π 8 _ r π
π # _ r Ē
Ē _ 7 r 9
ρ * * r ρ
ρ # _ r Ĕ
Ĕ _ 8 r 9
ς * * r ς
ς # _ r Ė
Ė _ 9 r Ā
Č _ 0 r #
σ * * r σ
σ # _ r Ę
σ 9 _ r σ
Ę _ 1 r Ď
Ď _ 0 r B
τ * * r τ
τ # _ r Ě
Ě _ 2 r Ď
υ * * r υ
υ # _ r Ĝ
Ĝ _ 3 r Ğ
Ğ _ 0 r Ƒ
φ * * r φ
φ 3 _ r φ
φ 9 _ r φ
φ # _ r Ġ
Ġ _ 4 r Ď
χ * * r χ
χ # _ r Ģ
Ģ _ 5 r Ď
ψ * * r ψ
ψ # _ r Ĥ
Ĥ _ 6 r Ğ
ω * * r ω
ω # _ r Ħ
ω 6 _ r ω
ω 9 _ r ω
Ħ _ 7 r Ď
Α * * r Α
Α # _ r Ĩ
Ĩ _ 8 r Ď
Β * * r Β
Β # _ r Ī
Ī _ 9 r Ğ
Γ * * r Γ
Γ 9 _ r Γ
Γ # _ r Ĭ
Ĭ _ B r Į
Į _ u r İ
İ _ z r Ĳ
Ĳ _ z r halt
Ĵ _ 1 r #
Ķ _ 1 r F
¬ * * r ¬
¬ 1 _ r ¬
¬ 0 _ r ¬
¬ # _ r Ĺ
Ĺ _ 1 r Ĵ
- * * r -
- 2 _ r -
- 0 _ r -
- # _ r Ļ
Ļ _ 2 r Ķ
= * * r =
= 3 _ r =
= 0 _ r =
= # _ r Ľ
Ľ _ 3 r Ĵ
+ * * r +
+ 4 _ r +
+ 0 _ r +
+ # _ r Ŀ
Ŀ _ 4 r Ĵ
{ * * r {
{ 5 _ r {
{ 0 _ r {
{ # _ r Ł
Ł _ 5 r Ķ
} * * r }
} 6 _ r }
} 0 _ r }
} # _ r Ń
Ń _ 6 r Ĵ
[ * * r [
[ 7 _ r [
[ 0 _ r [
[ # _ r Ň
Ň _ 7 r Ĵ
] * * r ]
] 8 _ r ]
] 0 _ r ]
] # _ r Ņ
Ņ _ 8 r Ķ
: * * r :
: 9 _ r :
: 0 _ r :
: # _ r Ŋ
Ŋ _ 9 r Ĵ
F _ F r i
i _ i r ȥ
ȥ _ z r ź
ź _ z r #
Ƒ _ F r í
í _ i r ż
ż _ z r ƶ
ƶ _ z r B
B _ B r u
u _ u r z
z _ z r ź

Try it online!

jq, 45 bytes
range(100)+1|(1-.%3)*"fizz"+(1-.%5)*"buzz"//.
# explanation
range(100)+1| # for each number in range 0-99 + 1
      . % 3 ) #   the current number modulo 3
 ( 1 -        #   the important thing is this gives 1 for 0 and an invalid
              #   number (0 or negative) for any positive number
       *"fizz"#   "fizz" repeated that many times. For a negative or 0 number
              #   this returns null
 + ..."buzz"  #   concatenated with the same thing but for buzz.
              #   null + anything is that thing, so for a number not divisible by
              #   3 or 5 this returns null
   // .       #   if the result is null, the number itself
              # implicit output

For best results run with jq -rn '...' | less.

C#, 95 91 bytes
for(int x=0;x++<100;)System.Console.WriteLine((x%3<1?"Fizz":"")+(x%5<1?"Buzz":x%3<1?"":x));

I do not take credit for this solution. I merged two solutions together:

C#, 97 bytes from mattnewport using the new C# 9 top level
statements.
C# using LINQ, 186 from Bill Tür using old fashioned C# but with Linq.
Java, 130 bytes from Geobits which he actually coded in java, but part of it works in C#  too.

This solution requires C# 9, but does not use Linq.

Javastack, 123 bytes
100 times context 1 add "Buzz"context 1 add 5 mod 0 equal repeat "Fizz"context 1 add 3 mod 0 equal repeat add logicor print

Try it online!
Context is everything. This is different to Wasif's Javastack answer because it uses a loop instead of a map, as well as extensive use of the context variable (totally not inspired by a certain golfing language made by a certain cg user with Flowey as his pfp).
Roughly equivalent to:
100ʁ ( n 1+ `Fizz` n 1+ 3 ḋt ¬ẋ `Buzz` n 1+ 5 ḋt ¬ẋ + ⟇, )

in vyxal.
You don't know how nice it was to write a Javastack answer without restrictions after 13 rounds of C&R.

I see. Don't worry, there'll be a #10...

CATHY, 420 bytes
cathYcathycathyCathYcatHYCAthycATHyCatHYCAtHycaThYCAthycATHyCatHYcaThYCAthyCaTHYCatHYcathYCAtHycAThycAThYcathYCAtHycAtHYCatHyCatHYCathYcaTHYcathyCATHycathYcathycaThYCATHycaTHycaTHyCATHycathYcathYcaTHYCATHycAtHycAtHycAtHycatHycAThycathYcatHycatHyCATHycatHycAThYcAtHycAThYcATHycAtHyCatHyCAtHyCathYcATHycAtHyCatHyCatHYcathYCAtHycAThycAThYcathYCAtHycAtHYcathYcathycathyCathYcathyCATHycathycAThYCaTHYCatHycAThYcAtHyCathYCAThY

Try it Online!
What have I done...
In normal form:
100⟑3τƒ:$5τƒ:5τJ:1$/*1$-;:⟑70C105C66C117C+++2/122C2*+*ƒ+;$⟑ƒ+;:1$/*1$-100⟑0C0*J;*+⟑,
=== Part 1: divisors ===
100⟑3τƒ:$5τƒ:5τJ:1$/*1$-;
100⟑                    ; # Map 1...100 to...
    3τƒ:                  # Convert to base 3 and get the last (dup-reduce)
        $5τƒ:             # Also convert to base 5 and get last (dup-reduce)
             5τJ          # Wrap in a list by converting to base 5 again, and concat
                :1$/      # Duplicate and take reciprocal
                    *     # Multiply, resolving 1+s to 1 and 0s to 0
                     1$-  # Subtract from 1
                          # Leaving [divisible by 3, divisible by 5]

=== Part 2: Fizz and Buzz ===
:⟑70C105C66C117C+++2/122C2*+*ƒ+;
:⟑                             ; # Duplicate previous and map to...
  70C105C66C117C+++              # Construct string "FiBu"
                   2/            # Divide into two pieces
                     122C        # chr(122) = z
                         2*+     # Double and append to each
                            *ƒ+  # Repeat by the above and concatenate
=== Part 3: Putting it together ===
$⟑ƒ+;:1$/*1$-100⟑0C0*J;*+⟑,
$⟑ƒ+;                       # Swap and sum each
     :1$/*1$-               # Turn 2s into 1s
             100⟑     ;     # Map 1...100 to...
                 0C0*J      # Concatenate the empty string (stringify)
                       *    # Repeat numbers by amounts
                        +   # Concatenate
                         ⟑, # Over each, print

Typescript Type System + ts-arithmetic, 257 bytes
import{Mod,Add}from"ts-arithmetic"
type x<n extends 0>=`${Mod<n,3>extends 0?"Fizz":""}${Mod<n,5>extends 0?"Buzz":""}`
type c<n extends 0>=x<n>extends""?n:x<n>
type a<z,n=1>=`${c<n>}
${n extends z?"":a<z,Add<n,1>>}`
type _=`${a<33>}
${a<66,33>}
${a<100,66>}`

Try it at TS Playground
The output is in the _ type, not emitted to STDOUT because the TS type system doesn't have that.
I've done some golfing but this can still be golfed heavily, maybe below 200 with a slightly different technique.
Unfortunately, we can't have type _=a<100> because TS won't generate recursive types more than 45-ish layers deep, so it has to be separated into three segments

226, no dependency

245 without type errors

I'm going to work on golving this much more, hopefully below 200 bytes

@ASCII-only I posted a follow up to this which is 227 with no dependency and no type errors: https://codegolf.stackexchange.com/a/267488/108687

Uiua, 48 bytes
∵(&p□/⊂∵!♭▽∶⊂{"Fizz""Buzz"}∶⊂∶¬/↥.=0◿3_5.)+1⇡100

Try it Online
What if APL but stack? That's the core question of Uiua and given that the shortest APL fizzbuzz is 7 bytes shorter, I clearly aren't stacking efficiently.
Explained
∵(&p□/⊂∵!♭▽∶⊂{"Fizz""Buzz"}∶⊂∶¬/↥.=0◿3_5.)+1⇡100
                                          +1⇡100  # The range [1, 100]
∵(                                       )        # To each number n in that range
                                  =0◿3_5          #   Push whether the number is divisible by 3 and 5
                            ⊂∶¬/↥.                #   Append to that list the maximum. This serves as a check as to whether the number should be printed, or a fizzbuzz string.
            ⊂{"Fizz""Buzz"}∶                      #   The list ["Fizz", "Buzz"] with n appended. These are all constants (i.e. functions that return the value) for array model reasons.
          ▽∶                                      #   Use the modulo mask from earlier to select values from ^
     /⊂∵!♭                                        #   Flatten, deconstantify each, and join into a single 1d array
    □                                             #   Wrap back in a constant for array model reasons
  &p                                              #   And print the result on STDOUT

Created with the help of Luminespire.

MSX-BASIC, 106 bytes
1FORI=1TO100:IFIMOD3=0ANDIMOD5=0THEN?"FizzBuzz"ELSEIFIMOD3=0THEN?"Fizz"ELSEIFIMOD5=0THEN?"Buzz"ELSE?I
2NEXT

The one-liner version to be executed in direct mode would be 120 bytes because all of the extra NEXTs needed before the ELSEs:
FORI=1TO100:IFIMOD3=0ANDIMOD5=0THEN?"FizzBuzz":NEXTELSEIFIMOD3=0THEN?"Fizz":NEXTELSEIFIMOD5=0THEN?"Buzz":NEXTELSE?I:NEXT

IFIMOD3=0ANDIMOD5=0 -> IFIMOD15=0? I think MSX BASIC could be tokenized too, which would decrease your byte count.

O, 53 52 bytes
I'm sure that there will be a better way to do this. Thanks to kirbyfan64sos for the implicit J.
"Buzz"JA.*1mrl{.3%{.5%{}{;J}?}{"Fizz"\5%{}{J+}?}?p}d

Try it here

52 bytes: "Buzz"JA.*1mrl{.3%{.5%{}{;J}?}{"Fizz"\5%{}{J+}?}?p}d. O has the implicit J variable like Pyth.

omg someone other than my mom used O <3

rs, 92 91 bytes
(_)^^(100)
+^(_+)(_)/\1 \1\2
\b((___)+)\b/Fi;\1
\b(_{5})+\b/Bu;
;_*/zz
\b(_+)\b/(^^\1)
 /\n

Saved 1 byte thanks to @MartinBüttner!
Live demo. (It may take a bit to run!)

Do you not have \0 in rs? You can probably save some bytes either way by using the trick from my Retina answer: \b((___)+)\b/Fi;\1 ... \b(_{5})+\b/Bu; ... ;_+/zz

@MartinBüttner Thanks! I updated the post. What exactly do you mean by \0?

Something to reference the entire match, not just a capturing group.

@MartinBüttner I guess not. :(

@MartinBüttner I'm just using Python's built-in substitution thing. I can easily override it, though...

The link for the live demo is outdated...

C# using LINQ, 168 186
using System.Linq;class A{static void Main(){foreach(var s in Enumerable.Range(1,100).Select(n=>n%3==0?n%5==0?"FizzBuzz":"Fizz":n%5==0?"Buzz":n.ToString()))System.Console.WriteLine(s);}}

haxe, 110 bytes
class Main{
  static function main()
    for(i in 1...101)
      Sys.println(i%3<1?"Fizz"+(i%5<1?"Buzz":""):i%5<1?"Buzz":i);
}

(newlines and indents added for clarity)
Haxe isn't much of a golfing language … I was trying to do something with enumerators:
class Main{
  static function main()
    for(i in 1...101)
      Sys.println(
        switch(i){
          case _%3=>0:i%5<1?"FizzBuzz":"Fizz";
          case _%5=>0:"Buzz";
          case _:i;
        }
      );
 }

But 140 bytes. :I

C#, 155 142 Bytes
class a{static void Main(){for(int i=0;i++<100;){var s="";if(i%3<1)s="Fizz";if(i%5<1)s+="Buzz";if(s=="")s=i+"";System.Console.WriteLine(s);}}}

Added as an alternate approach to the example using LINQ
Thanks @Riokmij!

You can replace the ==0's with <1, change the declaration of s with var instead of string, and replace the call to .ToString() by +"". Also, initial value for i should be 0.

Mathematica, 103 86 73 bytes
With 30 bytes saved thanks to @A Simmons!
f="Fizz";b="Buzz";Range@100/.{x_/;15∣x->f<>b,x_/;3∣x->f,x_/;5∣x->b}

You can use g=Divisible instead of the function definition, there's a leading space (and another one right after f<>b,), and you can use x~g~15 instead of x~g~3&&x~g~5. So f="Fizz";b="Buzz";g=Divisible;Range@100/.{x_/;x~g~15->f<>b,x_/;x~g~3->f,x_/;x~g~5->b}

You can use f="Fizz";b="Buzz";Range@100/.{x_/;15∣x->f<>b,x_/;3∣x->f,x_/;5∣x->b} for 73 bytes in 67 characters.

CatsAreFluffy, It turns out that your code gives incorrect answers for 5 and 100, for example.

It's a pair of zero width characters right after the g. Here's code for correcting that: FromCharacterCode[ToCharacterCode@#/.{8204|8203->(##&[])}]& (Don't worry, no zero widths here.)

MATLAB, 172 bytes
s=char(arrayfun(@(n){num2str(n)},[1:100 1e7])');s(3:3:end,1:4)=repmat('Fizz',33,1);s(5:5:100,1:4)=repmat('Buzz',20,1);s(15:15:100,:)=repmat('FizzBuzz',6,1);disp(s(1:100,:))

Nim, 100 76 73 bytes
for i in 1..100:echo max(["Fizz","",""][i%%3]&["Buzz",""][ord i%%5>0],$i)

Hm... still trying to learn Nim, and I'm thinking there's got to be a better way...

["Fizz",""][i*i%%3] saves 1. Using ord on a boolean is a useful tip, thanks for that.

VB.Net, 147 146 bytes
Module F
Sub Main()
For i=1To 100
Dim a=i Mod 3,b=i Mod 5
Console.WriteLine("{0:#}{1:;;Fizz}{2:;;Buzz}",If(a*b>0,i,0),a,b)
Next
End Sub
End Module

It uses the same conditional formatting trick as the C# answer by Pierre-Luc Pineault.
UPDATED: saved 1 byte thanks to Brian J

you can save a byte by using If instead of IIf. The difference is that IIf is a function that will evaluate both the true and false options, while If is an operator that will only evaluate the option it needs. Functionally doesn't make a difference in this case, but does save a character.

Ceylon, 368 144 123 96 bytes
shared void z(){for(i in 1..100){print(["FizzBuzz","Buzz","Fizz",i][(i%5).sign*2+(i%3).sign]);}}

Here we have the ungolfed original of 368 bytes:
shared void fizzBuzz() {
    for(i in 1..100) {
        if(3.divides(i)){
             if(5.divides(i)) {
                 print("FizzBuzz");
             } else {
                 print("Fizz");
             }
        } else {
            if(5.divides(i)) {
                print("Buzz");
            } else {
                print(i);
            }
        }
    }
}

In Ceylon, Integers are also just objects, so one can call methods on them (like the divides method here).
1..100 is syntactic sugar for span(1, 100), which is a Range<Integer>, which implements Iterable<Integer>, and can therefore be used with the for loop.
The print function takes one argument (of type Anything), stringifies it (i.e. if it's an object, calls its .string attribute, if it's null, takes "<null>") and prints it to the standard output.
Removing whitespace, using a shorter function name, and replacing x.divides(y) by the shorter y%x==0, which is essentially how divides is implemented, gives us this (144 bytes):
shared void f(){for(i in 1..100){if(i%3==0){if(i%5==0){print("FizzBuzz");}else{print("Fizz");}}else{if(i%5==0){print("Buzz");}else{print(i);}}}}

Of course, this is not the best which is possible ... this uses print and if much too often, and also does the check for divisibility by 5 twice.
Integers (or Numbers types in general) have also the .sign attribute, which is 1 for positive numbers, 0 for zero, and -1 for negatives. We can use that together with the remainder operator to get a different value for each of the four cases:  (i % 5).sign * 2 + (i % 3).sign]. This is 0 for FizzBuzz, 1 for Buzz, 2 for Fizz and 3 for the "plain" case. We can use this as an index of a tuple, coming to this 123-bytes program:
shared void z() {
    for(i in 1..100) {
        print(["FizzBuzz", "Buzz", "Fizz", i][(i%5).sign*2 + (i%3).sign]);
    }
}

([...] is the syntax for both Tuple creation (here a Tuple with element types String, String, String, Integer, formally Tuple<String|Integer, String, Tuple<String|Integer, String, Tuple<String|Integer, String, Tuple<Integer, Integer, Empty>>>, which can be written shorter as [String, String, String, Integer]) and lookup in a Correspondence (and this tuple type implements Correspondence<Integer, String|Integer>).
Removing the whitespace again gives us this 96 byte program:
shared void z(){for(i in 1..100){print(["FizzBuzz","Buzz","Fizz",i][(i%5).sign*2+(i%3).sign]);}}

Go, 162 158 145 143 142 139 bytes
package main;import."fmt";func main(){for i,p:=1,Println;i<101;i++{s:="";if i%3<1{s+="Fizz"};if i%5<1{s+="Buzz"};if s!=""{p(s)}else{p(i)}}}

Go Playground Link

zsh, 65 63 bytes
repeat 100 x=|let ++i%3||x=Fizz&&let i%5||x+=Buzz&&<<<${x:-$i}

Changed echo to <<<. It's now 2 bytes shorter, because <<< doesn't need a space.

repeat 100 x=|let ++i%3||x=Fizz&&let i%5||x+=Buzz&&echo ${x:-$i}

Python 2, 148 133 Bytes
def f(n):
 if n%3+n%5<1:return"FizzBuzz"
 if n%5<1:return"Buzz"
 if n%3<1:return"Fizz"
 return n
for x in map(f,range(1,101)):print x

it is possible to save some bytes by reducing the amount of indentation. (1 space is sufficient)

@Mhmd it's probably actually tabs, SE converts them to 4 spaces.

if n%3+n%5==0:return"FizzBuzz" -> if n%3+n%5==0:return f(3)+f(5) EDIT: nevermind i miscounted, it's the same

oh, but you can change ==0 to <1 everywhere it appears

This can be shortened significantly by removing the function and return logic: for i in range(100):print(i%3+i%5<1and'FizzBuzz')or(i%5<1and'Buzz')or(i%3<1and'Fizz')or i golfs it down to 89 bytes.

QB64, 102 94 bytes
FOR i=1TO 100
o$=MID$("Fizz",i*5MOD 15)+MID$("Buzz",i*5MOD 25)
IF""<o$THEN?o$ELSE WRITE i
NEXT

Doesn't work on actual QBasic; see below for why.
This program has one problem: QBasic/QB64 outputs to an 80x24 window, not a terminal, so the results can't be scrolled back. If you run the above code as-is, all you'll see is the lines from 78 onward. To prove that the code does 1 to 100 correctly, you can add the line SLEEP 1 right before NEXT for a 1-second delay on each iteration.
Ungolfed code and explanation
FOR i = 1 TO 100
    index = 5 * (i MOD 3)
    o$ = MID$("Fizz", index)
    index = 5 * (i MOD 5)
    o$ = o$ + MID$("Buzz", index)
    IF "" < o$ THEN
        PRINT o$
    ELSE
        WRITE i
    END IF
NEXT

On each iteration, we put the appropriate fizzes and buzzes into the string o$, check if it's empty, and output o$ or the number accordingly. The main question is how to get "Fizz" when i is divisible by 3 and "" otherwise. Here are the approaches I tried:
IF i MOD 3THEN o$=""ELSE o$="Fizz"
o$="":IF i MOD 3=0THEN o$="Fizz"
o$=MID$("Fizz",5*(i MOD 3))
o$=MID$("Fizz",i*5MOD 15)

The approach with MID$ is much shorter. This function takes 3 arguments--string, start index, and number of characters--and returns the appropriate substring. When the third argument is omitted, it takes everything from the start index to the end of the string. Here, when i is exactly divisible, the start index is 0 and we get the whole string; otherwise, it's something larger that's past the end of the string, so MID$ gives "".1
The other tricky part is printing numbers according to the spec. QBasic's PRINT command outputs positive numbers with leading spaces, which is occasionally useful but usually just annoying. The WRITE command, however, does not add a leading space--perfect for our purposes here.

1 Strings are 1-indexed in QBasic--i.e., in the string "abcd", a is at index 1 and d is at index 4. This is why I'm multiplying the mod result by 5: MID$("Fizz",4) gives "z". In actual QBasic, 0 isn't a legal index and gives Illegal function call; but in QB64, MID$("Fizz",0) happily returns the whole string instead of complaining.

Minkolang, 50 bytes
"d"[i1+d5%6&"Buzz"0c3%6&"Fizz"I1-3&N6@0gx(O)25*O].

Try it here.
Explanation
"d"[...].        For loop that loops from 0 to 99, then stops
i1+              Loop counter + 1 (so it's 1 to 100)
d5%6&"Buzz"      Divisibility test by 5, skips "Buzz" if not divisible
0c3%6&"Fizz"     Divisibility test by 3, skips "Fizz" if not divisible
I1-              Length of stack minus 1 (0 if there's no Fizz or Buzz)
3&N6@            Output as integer if ^ is 0, skip character output otherwise
0gx(O)           Dump the loop counter and output "Fizz"/"Buzz"/"FizzBuzz"
25*O             Print newline

Swift, 75 bytes
for n in 1...100{print(n%3*n%5>0 ?n:(n%3>0 ?"":"Fizz")+(n%5>0 ?"":"Buzz"))}

, 32 chars / 47 bytes
⩥Ṥⓜᵖ`FizzBuzz`ė⧺_%3⅋4,_%5?4:8)⋎_

Try it here (Firefox only).

scg, 51 bytes
1á01°r{d[[d"Buzz"]["Fizz"d"Buzz"+]]\3%!@\5%!@"
"}m

So, does this mean that scg is a real language now?
Explanation:
1                         .- adds 1 to the stack
 á01                      .- adds 101 to the stack
    °r                    .- range, adds array with 1-100 on the stack
      {                   .- start function for use in map
       d                  .- duplicates number
       [                  .- array
        [
         d                .- duplicate number again, ends up in array
          "Buzz"          .- wonder what this does
                ]         .- end array
        [
         "Fizz"
               d          .- duplicate fizz
         "Buzz"+          .- ends up with "FizzBuzz"
                ]
                 ]        .- end array. Ends up with a 2D array
        \                 .- gets number to calculate to the top
        3%                .- mod 3
          !               .- not, so any above 0 int turns to 0 and 0 turns to1
           @              .- get array value. Now you have two choices for output
            \5%!@         .- same as above but for 5.
                          .- now we have the correct fizzbuzz value
                 "\n"     .- pushes newline. I do not have variables yet so no shortcuts
                     }m   .- end function, map. output is implicit

C#, 174 bytes
void A(){for(int x=1;x<101;x++){if(x%15<1)Console.Write("FizzBuzz\n");else if(x%3<1)Console.Write("Fizz\n");else if(x%5<1)Console.Write("Buzz\n");else Console.WriteLine(x);}}

Ungolfed:
void A(){
    for (int x = 1; x < 101; x++) {
        if (x % 15 < 1) Console.Write("FizzBuzz\n");
        else if (x % 3 < 1) Console.Write("Fizz\n");
        else if (x % 5 < 1) Console.Write("Buzz\n");
        else Console.WriteLine(x);
    }
}

Javascript, 191 bytes
for(var i=1; i<=100; i++){
  var r = "";
  if( i%15 == 0 ? r = "FizzBuzz" : (i%5 == 0 ? r = "Buzz" : (i%3 == 0 ? r = "Fizz" : r = i)) ){
    console.log(r);
  }
}

Welcome to Programming Puzzles & Code Golf. Nice first answer! But please wrap your code into a code-block (indent with 4 spaces or use the button in the editor). Also you should format the header correctly, the common template for this here is ##<language>, <byte count> bytes. Also you have some unnecessary whitespaces in your code which you should remove.

Nice answer, but the goal of this challenge is to make your answer as short as possible. You can save a ton of bytes by removing all whitespace, and renaming result to r.

XQuery 3, 172 bytes
declare option output:method "text";string-join(for$x in 1 to 100 return if($x mod 15=0)then"FizzBuzz"else if($x mod 3=0)then"Fizz"else if($x mod 5=0)then"Buzz"else $x,"
")

There were only 7 XQuery answers on the whole site, I thought it could at least have its FizzBuzz ! Granted it's not very golfy, in particular when you need to add a 36 bytes preface so that it does not output an XML header.
I tested it with Saxon-HE's command-line XQuery tool (java net.sf.saxon.Query fizzbuzz.xq), with which I had to replace the w3-defined option declaration with declare option saxon:output "method=text";.

Tcl, 136 bytes
set f {Fizz 3 Buzz 5}
while {[incr n]<=100} {set s ""
foreach {m d} $f {if {$n%$d==0} {append s $m}}
if {$s eq ""} {puts $n} {puts $s}}

This solution, incidentally, is easily extensible to any combination of multiples. See The Smart Person's Mirage golf, where gnibbler posted the same idea (but in Python).
set iterations 100

set fizzies {
  Fizz 3
  Jazz 4
  Buzz 5
}

while {[incr n] <= $iterations} {
  set s ""
  foreach {name divisor} $fizzies {
    if {$n % $divisor == 0} {append s $name}
  }
  if {$s eq ""} {puts $n} {puts $s}
}

Oration, 98 bytes
literally, for i in range(1,100):x=""if i%3 else'Fizz';x+=""if i%5 else "Buzz";print x if x else i

ROOP, 187 bytes
1
V!         !<
(102)      1|
 e#r3##r5# a|
#H  #   # Y-<
   N   N  !
"Fizz""Buzz"

   mX  mX
### V-->  !
   A V---->
    #
  ' C
 V'e  "\n"
 |# M  #
 <V# #v
 C  A  C
  #X ##
    w
    O#

I will try to explain each section of code:
V!         !<  Add 1 to each number that goes to the left of the a
           1|  and sends it to the bottom of the V
           a|
           -<

(102)          The 102 falls to the left of the e and each number
 e             that passes over is compared to 102.
#H             If a number is equal then the H runs and ends the program

  #r3#         With each number that goes above the r
    #          the remainder of dividing by 3 is obtained.
   N           The N returns 1 if the number is 0, and 0 otherwise.
"Fizz"         The string "Fizz" falls and moves to the left of the m.
               The number is multiplied by the string
   mX          ("" or "Fizz" if it is 0 or 1 respectively)
###            The X removes the number when it moves to the right

               The same is done with 5 and "Buzz"

   mX  mX
    V-->      Both strings are concatenated with the A
   A          getting "", "Fizz", "Buzz" or "FizzBuzz"
    #

  ' C         The C changes the direction of advance of string, to the left.
  'e          At the same time the "e" compares the string with the empty string.
  #           The single quotes are a vertical literal string.

 V            The V and pipes redirects the string to the right of the C
 |            that changes the direction again in order that comes to the left of the A
 <V
 C  A

          Y   The original number is converted to a string with Y.
          !

          !   Pipes and teleporters (!) Redirects the string to below the V
     V---->

    M         The string falls to the right of the M and multiplies
   # #        with the number previously obtained by the e
    A         The result is above the A

      "\n"   The string "\n" falls on the v which makes a copy
    M  #     whenever there is a space below.
      v      The C changes the direction of the string so it goes to the left.
    A  C     It waits to the right of the A

    A        The A concatenate all 3 strings, the result is on the w that sends it
  #X ##      to the O representing the output. At the same time the X deletes the string.
    w
    O#

I hope it is comprehensible, English is not my main language.

Befunge, 65 bytes
_1+::3%^>55+,:"c"`#@
>"zuB"vv.#,,:,,<
|!:%5\ _:!"ziF"^
<,,:,,<:|*

Try it online!

tcl, 72
time {puts [expr [incr i]%3?$i%5?$i:"":"Fizz"][expr $i%5?"":"Buzz"]} 100

I think it is more golfable, to avoid the repetition of i%5
demo

It is more golfable for sure. For about half an hour I focused on trying to golf this more, but I couldn't find anything else. On code.golf ( a website ) there was an answer that was 71 bytes.

Valyrio, 13 bytes
s∫main [CF]

This is a fairly basic (and slightly unimaginative) answer.
Explanation
C pushes 100 to the stack, which means that ...
F is the FizzBuzz builtin. This was mainly added in as a basic stack based program but got left in as a command and I never got rid of it.

SmileBASIC, 70 bytes
Printing "Fizz" and "Buzz" is easy, the slightly more difficult part is to only print the number when required. There are basically 2 ways to do this (and they end up being the same length)
1: Print the number when I isn't divisible by 3 or 5
FOR I=0TO 100A=I MOD 3B=I MOD 5?"Fizz"*!A;"Buzz"*!B;STR$(I)*(A&&B)NEXT

2: Print the number if the cursor is at column 0:
FOR I=1TO 100?"Fizz"*!(I MOD 3);"Buzz"*!(I MOD 3);
?STR$(I)*!CSRX
NEXT

In a previous version of SB, % was used for MOD, making the program shorter:
Petit Computer BASIC, 62 bytes
FOR I=0TO 100?"Fizz"*!(I%3);"Buzz"*!(I%5);
?STR$(I)*!CSRX
NEXT

The language name should probably be "SmileBASIC 2.x" or something.

Cardinal 217 bytes
%x>+ v  >+++++~M! 8# "buzz"
0    #~0#+++~>M! # V  "fizz"
+ ^jM<  ~        V>#
+       V      > #xV
= 0              V
t ~             >#x
t t       v      V
* =   > #}#}     /
> ^              >}/
                   .

Try it Online
Explanation
%x
0
+
+
= 0
t ~
t t
* =
> ^

Initializes a pointer with an inactive value of 100 and active value of 0
>+ v
   #
^jM<

Loops around, incrementing the active value of the pointer and sending out a duplicate until the active value is equal to the inactive value (100)
  >+++++~M!
~0#+++~>M!

Checks if the value mod 3 or mod 5 is equal to 0
                   # "buzz"
        #        # V  "fizz"
        ~        V>#
        V      > #xV
                 V
                >#x
          v      V
      > #}#}     /
                 >}/
                   .

Uses reflectors and splitters in order to print only numbers that are not divisible by 3 or 5. Printing fizz when divisible by 3 and buzz when divisible by 5.

Java, 153 145 bytes
enum f{;static{for(int i=1;i<101;i++)System.out.println(i%3>0&i%5>0?i:(i%3<1&i%5<1?"FizzBuzz":(i%3<1?"Fizz":(i%5<1?"Buzz":0))));System.exit(0);}}

Not as long as I expected it to be, maybe because I ommited main function and used an enum. Quite overcomplicated print statement.
Ungolfed version(Modified to be readable) with comments:
enum f {;                                       // Required because it is an enum
    static {                                    // static block
        for (int i = 1; i < 101; i++) {         // loop from 1 to 100 inclusive
            boolean by3 = i % 3 == 0;
            boolean by5 = i % 5 == 0;

            if (!by3 && !by5)                   // Not divisible by 3 and 5
                System.out.println(i);          // Just show the number
            else if (by3 && by5)                // Divisible by both
                System.out.println("FizzBuzz"); // Show FizzBuzz
            else if (by3)                       // Divisible only by 3
                System.out.println("Fizz");     // Show Fizz
            else                                // Divisible only by 5
                System.out.println("Buzz");     // Show Buzz
        }
        System.exit(0);                         // Required because there can't be output to stderr and it would crash trying to run main function
    }
}

Ungolfed not modified:
enum f {;
    static {
        for (int i = 1; i < 101; i++)
            System.out.println(i % 3 > 0 & i % 5 > 0 ? i : (i % 3 < 1 & i % 5 < 1 ? "FizzBuzz" : (i % 3 < 1 ? "Fizz" : (i % 5 < 1 ? "Buzz" : 0))));
        System.exit(0);
    }
}

EDIT: Saved 8 bytes by replacing ==0 with <1, !=0 with >0 and && with &

Julia, 70 bytes
for i=1:100 println("$(i%3<1?"Fizz":"")$(i%5<1?"Buzz":i%3>0?i:"")")end

Julia has perl-like string formatting. Very nice for challenges like these.

REXX 81 Bytes
f.=""
f.0="buzz"
t.=""
t.0="fizz"
do i=1 to 100
  f=i//5
  t=i//3
  say overlay(t.t||f.f,i)
end

You can golf away four characters by removing the empty strings: f.= instead of f.="".

I tested f.= on a couple of online interpreters and they didn't like it.

All right, I only tested it with Regina.

q/kdb+, 58 56 49 bytes
Solution:
0{$[sum i:0=y mod 3 5;`Fizz`Buzz(&)i;y]}'1+(!)100

Example:
q)0{$[sum i:0=y mod 3 5;`Fizz`Buzz(&)i;y]}'1+(!)100
1
2
,`Fizz
4
,`Buzz
,`Fizz
7
8
,`Fizz
,`Buzz
11
,`Fizz
13
14
`Fizz`Buzz
16
...etc

Explanation:
0{$[sum i:0=y mod 3 5;`Fizz`Buzz where i;y]}'1+til 100  / ungolfed
 {                                         }'           / anonymous function that takes each-left and each-right
0                                                       / this would be parameter 'x' but we dont use it
                                               til 100  / til generates a list of 0..99
                                             1+         / adds 1 to every item in the list, thus 1..100
  $[                 ;                  ; ]             / switch, $[condition;true;false]
            y mod 3 5                                   / modulo operation on input for 3 and 5, mod[1;3 5] = 1 1
          0=                                            / is 0 equal to this result (basically a 'not' operation)
        i:                                              / save in i for later
    sum                                                 / add these, will get 0, 1 or 2. 0 is interpretted as false
                                 where i                / where gives indices where i is true
                      `Fizz`Buzz                        / 2 item list which gets indexed into (and implicitly returned)
                                     y                  / return the input if the condition was false

Notes:
This ^^ is pretty much a q version of the k solution, so I've written in a different way.. unfortunately it's about 50% slower :(
0{(`Fizz;`Buzz;y)(&)(0=a),all a:mod[y;3 5]}'1+(!)100

Here we are indexing into a list of Fizz, Buzz,  based on the result of the modulo operation... The k solution style is better.

Swift, 97 bytes
for i in 1...100{i%15==0 ?print("FizzBuzz"):i%3==0 ?print("Fizz"):i%5==0 ?print("Buzz"):print(i)}

Python 2, 57 bytes
for i in range(100):print i%3/2*"Fizz"+i%5/4*"Buzz"or i+1

Not the most beautiful code but it works at least with
python -c

groovy, 55 bytes
Borrows idea from answer by @feersum https://codegolf.stackexchange.com/a/58623
100.times{println'Fizz'*(it%3/2)+'Buzz'*(it%5/4)?:it+1}

Welcome to PPCG! :)

Acc!!, 260 bytes
Count i while 100-i {
i%3/2*2
Count f while _/2 {
Write 70
Write 105
Write 122
Write 122
1
}
_+i%5/4*2
Count b while _/2 {
Write 66
Write 117
Write 122
Write 122
1
}
Count d while 1-_ {
(i+1)/10
Count z while _ {
Write 48+_
0
}
Write 48+(i+1)%10
1
}
Write 10
}

Try it online!
Explanation
Once you know how Acc!! works, this is pretty straightforward. Count while loops increment their variable from 0 as long as their condition is true. Write takes an ASCII code and outputs the corresponding character. Bare expressions like i%3/2*2 are assigned to the accumulator, _. Division is integer division.
Our code iterates i from 0 through 99 (thus, the number in question on each iteration is actually i+1).

If i%3 is 2 (i.e. i+1 is divisible by 3), we want to print Fizz.

Set the accumulator to i%3/2*2, which is 0 if i%3 is less than 2, and 2 otherwise.
Loop with condition _/2; we enter the loop iff the accumulator was set to 2 last step.
Inside the loop, write Fizz.
Set the accumulator to 1, breaking out of the f loop while keeping a record that we Fizzed.

If i%5 is 4 (i.e. i+1 is divisible by 5), we want to print Buzz. Same approach as above, except we now add i%5/4*2 to the existing accumulator value to preserve a possible 1 from the Fizz step.
If we printed Fizz and/or Buzz, the accumulator is now 1; otherwise, it is 0. If it is 0, we need to output the number.

Loop with condition 1-_: we enter the loop iff the accumulator is not 1.
Set accumulator to (i+1)/10, the 10's digit.
If that result is not 0, write the 10's digit, and set accumulator to 0 to break out of the z loop.
Write the 1's digit, (i+1)%10.
Set accumulator to 1 to break out of the d loop.

Finally, write a newline.

tinylisp repl, 130 bytes
(d f(q((n # %)(i(e n 100)(q Buzz)(i(disp(i #(i % n(q Buzz))(i %(q Fizz)(q FizzBuzz))))0(f(a n 1)(i #(s # 1)2)(i %(s % 1)4
(f 1 2 4

Try it online! (Note that the repl auto-completes parentheses at the ends of lines; these have been filled in on the TIO version.)
Explanation
It took me a while to realize I could do FizzBuzz in tinylisp, since the language doesn't have strings. However, it does have the Name type, which can be any run of non-whitespace, non-parenthesis characters; and it also has the disp command, which outputs a value followed by a newline. Together with some creative abuse of recursion, we can get the desired output.
We define a function f with three arguments:

n is the counter. We will start at 1 and recurse until 100.
# is the number of iterations till the next divisible-by-3 number. (Mnemonic: Shift-3)
% is the number of iterations till the next divisible-by-5 number. (Mnemonic: Shift-5)

The first thing f does is check whether n is 100. If so, we return Buzz. This value gets passed all the way up the call stack and printed at the end.
If not, we need to use disp to print either the number, Fizz, Buzz, or FizzBuzz, depending on the values of # and %:

If # and % are both nonzero (truthy), the number is not divisible by 3 or 5. Display the number, n.
If # is nonzero but % is zero, the number is divisible by 5 but not 3. Display Buzz.
If # is zero but % is nonzero, the number is divisible by 3 but not 5. Display Fizz.
If # and % are both zero, the number is divisible by 3 and 5. Display FizzBuzz.

Since tinylisp does not have an equivalent to Common Lisp's progn, disp'ing something and then returning a value requires a little trickery. Since disp always returns (), which is falsey, we can use the disp call as the condition of an if (i). The true branch will never be evaluated (0 is a convenient placeholder), and we can put the actual return value in the false branch.
This return value is a recursive call. We add 1 to n, and we subtract 1 from # and % unless they are zero, in which case we reset them to (3-1) or (5-1), respectively.
Ungolfed, using the standard library for long names of builtins (TIO):
(load library)

(def fizz-buzz
 (lambda (counter steps-till-fizz steps-till-buzz)
  (if (equal? counter 100)
   (q Buzz)
   (if
    (disp
     (if steps-till-fizz
      (if steps-till-buzz counter (q Buzz))
      (if steps-till-buzz (q Fizz) (q FizzBuzz))))
    (comment Return val of disp is always falsey, so the true branch is never executed)
    (fizz-buzz
     (add2 counter 1)
     (if steps-till-fizz (sub2 steps-till-fizz 1) 2)
     (if steps-till-buzz (sub2 steps-till-buzz 1) 4))))))

(fizz-buzz 1 2 4)

Ken Thompson: "Thompson:the original LISP... you know I think it's a horrible language. I really do. But, I was struck with the idea of defining very, very low level semantics,... it defines its own interpreter. It's always been a problem when you describe a language to say what constructs it recognizes and what they actually do and [Lisp] was the cleanest, simplest, most recursive, beautiful semantics of a language I've ever seen. Probably even to this day. But, unfortunately, what it describes I think is just a horrible language." tinylisp is a bit less scary IMHO!

Java (OpenJDK 8), 127 bytes
interface J{static void main(String[]a){for(int i=0;i++<100;)System.out.println((i%3<1?"Fizz":"")+(i%5<1?"Buzz":i%3<1?"":i));}}

Try it online!
ungolfed:
interface J {
    static void main(String[] a) {
        for (int i = 0; i++ < 100;)
            System.out.println((i % 3 < 1 ? "Fizz" : "") + (i % 5 < 1 ? "Buzz" : i % 3 < 1 ? "" : i));
    }
}

KoopaScript, 250 characters
def i 1 if \%va is \%vu set a 1;setath b \%va %% 3;setath c \%va %% 5;setath e \%va %% 15;if \%vb is 0 if \%vc not 0 print Fizz;if \%vb not 0 if \%vc is 0 print Buzz;if \%ve is 0 print FizzBuzz;if \%vb not 0 if \%vc not 0 print \%va;setath a \%va + 1

Guide to reading: Don't. Either learn KoopaScript more or less entirely by looking at the code (my documentation isn't that great) or just take my word for it that it works.
By the way, KoopaScript is an interpreted language I made (not specifically for this) that runs inside ActionScript 2, and doesn't actually have else statements, or... most of the stuff that makes other examples short. All functions are one line, so this was pretty easy. Here's the GitHub repo.

This looks like quite the painful programming language to use haha. Welcome to PPCG! :)

Thanks! Yeah, it is a bit painful, but I can't really be bothered to add stuff like arrays. I made a pi approximator and a prime number generator (both very slow), both were quite painful because of the lack of useful functions.

uBASIC, 106 96 bytes
Improved syntax, and fixed a bug
0ForI=1To100:S$="":IfIMod3=0ThenS$="Fizz"
1IfIMod5=0ThenS$=S$+"Buzz"
2IfS$=""Then?I,
3?S$
4NextI

Try it online!

Whitespace, 307 bytes
[S S S N
_Push_0][N
S S N
_Create_Label_LOOP][S S S T N
_Push_1][T  S S S _Add][S N
S _Duplicate][S N
S _Duplicate][S S S T   T   N
_Push_3][T  S T T   _Modulo][N
T   S T N
_Jump_to_Label_FIZZ_if_0][N
S S S N
_Create_Label_RETURN_FIZZ][S N
S _Duplicate][S N
S _Duplicate][S S S T   S T N
_Push_5][T  S T T   _Modulo][N
T   S T T   N
_Jump_to_Label_BUZZ_if_0][N
S S S S N
_Create_Label_RETURN_BUZZ][S S S T  T   S S T   S S N
_Push_100][T    S S T   _Subtract][N
T   S T T   T   N
_Jump_to_Label_EXIT_WITH_ERROR_if_0][N
S T T   T   T   T   N
_Call_Label_PRINT_INT][S S S T  S T S N
_Push_10][T N
S S _Print_as_character][N
S N
N
_Jump_to_Label_LOOP][N
S S T
_Create_Label_FIZZ][S S S T S S S T T   S N
_Push_70][T N
S S _Print_as_character][S S S T    T   S T S S T   N
_Push_105][T    N
S S _Print_as_character][S S S T    T   T   T   S T S N
_Push_122][S N
S _Duplicate][T N
S S _Print_as_character][T  N
S S _Print_as_character][N
S N
S
_Return_to_Label_FIZZ_RETURN][N
S S T   T   N
_Create_Label_BUZZ][S S S T S S S S T   S N
_Push_66][T N
S S _Print_as_character][S S S T    T   T   S T S T N
_Push_117][T    N
S S _Print_as_character][S S S T    T   T   T   S T S N
_Push_122][S N
S _Duplicate][T N
S S _Print_as_character][T  N
S S _Print_as_character][N
S N
S S N
_Return_to_Label_BUZZ_RETURN][N
S S T   T   T   T   N
_Create_Label_PRINT_INT][S N
S _Duplicate][S S S T   T   N
_Push_3][T  S T T   _Modulo][N
T   S S T   N
_Jump_to_Label_LOOP_if_0][S N
S _Duplicate][S S S T   S T N
_Push_5][T  S T T   _Modulo][N
T   S S T   N
_Jump_to_Label_LOOP_if_0][T N
S T _Print_as_integer][N
T   N
_Return][N
S S S T N
_Create_Label_RETURN][N
T   N
_Return]

Letters S (space), T (tab), and N (new-line) added as highlighting only.
[..._some_action] added as explanation only.
Try it online (with raw spaces, tabs and new-lines only).
Can definitely be golfed. If-checks are rather annoying in Whitespace, and I still have to get used to them some more.
EDIT: Fixed TIO version. Will try to golf it some more later.
General explanation in Pseudo-code:
Integer i = 0
Start LOOP
  Increase i by 1
  If i modulo 3 is 0: Call function FIZZ()
  If i modulo 5 is 0: Call function BUZZ()
  If i is 100: Stop program
  Call function PRINT_INT(i)
  Print new-line
  Go to next iteration of the LOOP

function FIZZ():
  Print "Fizz"
  Return

function BUZZ():
  Print "Buzz"
  Return

function PRINT_INT(integer i):
  If i modulo 3 is 0: Return
  If i modulo 5 is 0: Return
  Print i
  Return

Example run:
Command        Explanation                  Stack                 STDOUT    STDERR

SSSN           Push 0                       [0]
NSSN           Create Label_LOOP            [0]

SSSTN          Push 1                       [0,1]
TSSS           Add (0+1)                    [1]
SNS            Duplicate (1)                [1,1]
SNS            Duplicate (1)                [1,1,1]
SSSTTN         Push 3                       [1,1,1,3]
TSTT           Modulo (1%3)                 [1,1,1]
NTSTN          Jump to Label_FIZZ if 0      [1,1]
NSSSSN         Create Label_RETURN_FIZZ     [1,1]
SNS            Duplicate (1)                [1,1,1]
SNS            Duplicate (1)                [1,1,1,1]
SSSTSTn        Push 5                       [1,1,1,1,5]
TSTT           Modulo (1%5)                 [1,1,1,1]
NTSTTN         Jump to Label_BUZZ if 0      [1,1,1]
NSSSSN         Create Label_RETURN_BUZZ     [1,1,1]
SSSTTSSTSSN    Push 100                     [1,1,1,100]
TSST           Subtract (1-100)             [1,1,-99]
NTSTTTN        Jump to Label_EXIT if 0      [1,1]
NSTTTTTN       Call Label_PRINT_INT         [1,1]
 NSSTTTTN      Create Label_PRINT_INT       [1,1]
 SNS           Duplicate (1)                [1,1,1]
 SSSTTN        Push 3                       [1,1,1,3]
 TSTT          Modulo (1%3)                 [1,1,1]
 NTSSTN        Jump to Label_RETURN if 0    [1,1]
 SNS           Duplicate (1)                [1,1,1]
 SSSTSTN       Push 5                       [1,1,1,5]
 TSTT          Modulo (1%5)                 [1,1,1]
 NTSSTN        Jump to Label_RETURN if 0    [1,1]
 TNST          Print as integer             [1]                      1
 NTN           Return                       [1]
SSSTSTSN       Push 10                      [1,10]
TNSS           Print as character           [1]                      \n
NSNN           Jump to Label_LOOP           [1]

SSSTN          Push 1                       [1,1]
TSSS           Add (1+1)                    [2]
SNS            Duplicate (2)                [2,2]
SNS            Duplicate (2)                [2,2,2]
SSSTTN         Push 3                       [2,2,2,3]
TSTT           Modulo (2%3)                 [2,2,2]
NTSTN          Jump to Label_FIZZ if 0      [2,2]
NSSSSN         Create Label_RETURN_FIZZ     [2,2]
SNS            Duplicate (2)                [2,2,2]
SNS            Duplicate (2)                [2,2,2,2]
SSSTSTn        Push 5                       [2,2,2,2,5]
TSTT           Modulo (2%5)                 [2,2,2,2]
NTSTTN         Jump to Label_BUZZ if 0      [2,2,2]
NSSSSN         Create Label_RETURN_BUZZ     [2,2,2]
SSSTTSSTSSN    Push 100                     [2,2,2,100]
TSST           Subtract (2-100)             [2,2,-98]
NTSTTTN        Jump to Label_EXIT if 0      [2,2]
NSTTTTTN       Call Label_PRINT_INT         [2,2]
 NSSTTTTN      Create Label_PRINT_INT       [2,2]
 SNS           Duplicate (2)                [2,2,2]
 SSSTTN        Push 3                       [2,2,2,3]
 TSTT          Modulo (2%3)                 [2,2,2]
 NTSSTN        Jump to Label_RETURN if 0    [2,2]
 SNS           Duplicate (2)                [2,2,2]
 SSSTSTN       Push 5                       [2,2,2,5]
 TSTT          Modulo (2%5)                 [2,2,2]
 NTSSTN        Jump to Label_RETURN if 0    [2,2]
 TNST          Print as integer             [2]                      2
 NTN           Return                       [2]
SSSTSTSN       Push 10                      [2,10]
TNSS           Print as character           [2]                      \n
NSNN           Jump to Label_LOOP           [2]

SSSTN          Push 1                       [2,1]
TSSS           Add (3+1)                    [3]
SNS            Duplicate (3)                [3,3]
SNS            Duplicate (3)                [3,3,3]
SSSTTN         Push 3                       [3,3,3,3]
TSTT           Modulo (3%3)                 [3,3,0]
NTSTN          Jump to Label_FIZZ if 0      [3,3]
NSST           Create Label_FIZZ            [3,3]
SNS            Duplicate (3)                [3,3,3]
SNS            Duplicate (3)                [3,3,3,3]
 SSSTSSSTTSN   Push 70                      [3,3,3,3,70]
 TNSS          Print as character           [3,3,3,3]                F
 SSSTTSTSSTN   Push 105                     [3,3,3,3,122]
 TNSS          Print as character           [3,3,3,3]                i
 SSSTTTTSTSN   Push 122                     [3,3,3,3,122]
 SNS           Duplicate (122)              [3,3,3,3,122,122]
 TNSS          Print as character           [3,3,3,3,122]            z
 TNSS          Print as character           [3,3,3,3]                z
 NSNS          Jump to Label_RETURN_FIZZ    [3,3,3,3]
NSSSSN         Create Label_RETURN_FIZZ     [3,3,3,3]
SSSTSTN        Push 5                       [3,3,3,3,5]
TSTT           Modulo (3%5)                 [3,3,3,3]
NTSTTN         Jump to Label_BUZZ if 0      [3,3,3]
NSSSSN         Create Label_RETURN_BUZZ     [3,3,3]
SSSTTSSTSSN    Push 100                     [3,3,3,100]
TSST           Subtract (3-100)             [3,3,-97]
NTSTTTN        Jump to Label_EXIT if 0      [3,3]
NSTTTTTN       Call Label_PRINT_INT         [3,3]
 NSSTTTTN      Create Label_PRINT_INT       [3,3]
 SNS           Duplicate (3)                [3,3,3]
 SSSTTN        Push 3                       [3,3,3,3]
 TSTT          Modulo (3%3)                 [3,3,0]
 NTSSTN        Jump to Label_RETURN if 0    [3,3]

  Stack contains additional leading [3, but we'll ignore it in this explanation
SSSTN          Push 1                       [3,1]
TSSS           Add (3+1)                    [4]
SNS            Duplicate (4)                [4,4]
SNS            Duplicate (4)                [4,4,4]
SSSTTN         Push 3                       [4,4,4,3]
TSTT           Modulo (4%3)                 [4,4,1]
NTSTN          Jump to Label_FIZZ if 0      [4,4]
NSSSSN         Create Label_RETURN_FIZZ     [4,4]
SNS            Duplicate (4)                [4,4,4]
SNS            Duplicate (4)                [4,4,4,4]
SSSTSTN        Push 5                       [4,4,4,4,5]
TSTT           Modulo (4%5)                 [4,4,4,4]
NTSTTN         Jump to Label_BUZZ if 0      [4,4,4]
NSSSSN         Create Label_RETURN_BUZZ     [4,4,4]
SSSTTSSTSSN    Push 100                     [4,4,4,100]
TSST           Subtract (4-100)             [4,4,-96]
NTSTTTN        Jump to Label_EXIT if 0      [4,4]
NSTTTTTN       Call Label_PRINT_INT         [4,4]
 NSSTTTTN      Create Label_PRINT_INT       [4,4]
 SNS           Duplicate (4)                [4,4,4]
 SSSTTN        Push 3                       [4,4,4,3]
 TSTT          Modulo (4%3)                 [4,4,1]
 NTSSTN        Jump to Label_RETURN if 0    [4,4]
 SNS           Duplicate (4)                [4,4,4]
 SSSTSTN       Push 5                       [4,4,4,5]
 TSTT          Modulo (4%5)                 [4,4,4]
 NTSSTN        Jump to Label_RETURN if 0    [4,4]
 TNST          Print as integer             [4]                      4
 NTN           Return                       [4]
SSSTSTSN       Push 10                      [4,10]
TNSS           Print as character           [4]                      \n
NSNN           Jump to Label_LOOP           [4]

SSSTN          Push 1                       [4,1]
TSSS           Add (4+1)                    [5]
SNS            Duplicate (5)                [5,5]
SNS            Duplicate (5)                [5,5,5]
SSSTTN         Push 3                       [5,5,5,3]
TSTT           Modulo (5%3)                 [5,5,2]
NTSTN          Jump to Label_FIZZ if 0      [5,5]
NSSSSN         Create Label_RETURN_FIZZ     [5,5]
SNS            Duplicate (5)                [5,5,5]
SNS            Duplicate (5)                [5,5,5,5]
SSSTSTN        Push 5                       [5,5,5,5,5]
TSTT           Modulo (5%5)                 [5,5,5,0]
NTSTTN         Jump to Label_BUZZ if 0      [5,5,5]
 NSSTTN        Create Label_BUZZ            [5,5,5]
 SSSTSSSSTSN   Push 66                      [5,5,5,66]
 TNSS          Print as character           [5,5,5]                  B
 SSSTTTSTSTN   Push 117                     [5,5,5,117]
 TNSS          Print as character           [5,5,5]                  u
 SSSTTTTSTSN   Push 122                     [5,5,5,122]
 SNS           Duplicate (122)              [5,5,5,122,122]
 TNSS          Print as character           [5,5,5,122]              z
 TNSS          Print as character           [5,5,5]                  z
 NSNS          Jump to Label_RETURN_FIZZ    [5,5,5]
NSSSSN         Create Label_RETURN_BUZZ     [5,5,5]
SSSTTSSTSSN    Push 100                     [5,5,5,100]
TSST           Subtract (5-100)             [5,5,-95]
NTSTTTN        Jump to Label_EXIT if 0      [5,5]
NSTTTTTN       Call Label_PRINT_INT         [5,5]
 NSSTTTTN      Create Label_PRINT_INT       [5,5]
 SNS           Duplicate (5)                [5,5,5]
 SSSTTN        Push 3                       [5,5,5,3]
 TSTT          Modulo (5%3)                 [5,5,2]
 NTSSTN        Jump to Label_RETURN if 0    [5,5]
 SNS           Duplicate (5)                [5,5,5]
 SSSTSTN       Push 5                       [5,5,5,5]
 TSTT          Modulo (4%5)                 [5,5,0]
 NTSSTN        Jump to Label_RETURN if 0    [5,5]

... etc. etc.

SSSTN          Push 1                       [99,1]
TSSS           Add (99+1)                   [100]
SNS            Duplicate (100)              [100,100]
SNS            Duplicate (100)              [100,100,100]
SSSTTN         Push 3                       [100,100,100,3]
TSTT           Modulo (100%3)               [100,100,1]
NTSTN          Jump to Label_FIZZ if 0      [100,100]
NSSSSN         Create Label_RETURN_FIZZ     [100,100]
SNS            Duplicate (100)              [100,100,100]
SNS            Duplicate (100)              [100,100,100,100]
SSSTSTN        Push 5                       [100,100,100,100,5]
TSTT           Modulo (100%5)               [100,100,100,0]
NTSTTN         Jump to Label_BUZZ if 0      [100,100,100]
 NSSTTN        Create Label_BUZZ            [100,100,100]
 SSSTSSSSTSN   Push 66                      [100,100,100,66]
 TNSS          Print as character           [100,100,100]            B
 SSSTTTSTSTN   Push 117                     [100,100,100,117]
 TNSS          Print as character           [100,100,100]            u
 SSSTTTTSTSN   Push 122                     [100,100,100,122]
 SNS           Duplicate (122)              [100,100,100,122,122]
 TNSS          Print as character           [100,100,100,122]        z
 TNSS          Print as character           [100,100,100]            z
 NSNS          Jump to Label_RETURN_FIZZ    [100,100,100]
NSSSSN         Create Label_RETURN_BUZZ     [100,100,100]
SSSTTSSTSSN    Push 100                     [100,100,100,100]
TSST           Subtract (100-100)           [100,100,0]
NTSTTTN        Jump to Label_EXIT if 0      [100,100]                          error

Husk, 35 bytes
m§Ysλṁ!⁰₇ḣ3)ḣ100
¶Σfm%⁰NC2¨¶¶¶⌈iΩZu

Try it online!
I feel like I'm missing some opportunities for cleverness here. Like, I'm not really pleased with that lambda sitting there on the first line and having to be manually closed. But anyway, here we are.
Explanation
I'll explain the second line first. It's a function TNum -> [[TChar]] that maps
1 -> []
2 -> ["","","Fizz"]
3 -> ["","","","","Buzz"]

It works like this:
¶Σfm%⁰NC2¨¶¶¶⌈iΩZu
         ¨¶¶¶⌈iΩZu --The compressed string "\n\n\n\nFiBuzz"
       C2¨¶¶¶⌈iΩZu --cut; the list ["\n\n", "\n\n", "Fi", "Bu", "zz]
   m%⁰N            --nats mod input, i.e, with input 3, [1,2,0,1,2,...]
  fm%⁰NC2¨¶¶¶⌈iΩZu --filter;so grab (1) nothing, (2) pairs 135, (3) pairs 1245
 Σfm%⁰NC2¨¶¶¶⌈iΩZu --concat;now at (1) [] (2) ["\n\nFizz"] (3) ["\n\n\n\nBuzz"]
¶Σfm%⁰NC2¨¶¶¶⌈iΩZu --split by newlines to return claimed result

Next, the lambda in the first line. It has type TNum -> [TChar]; given an integer, it returns "", "Fizz", "Buzz", or "FizzBuzz" as appropriate. In detail:
λṁ!⁰₇ḣ3)
     ḣ3  --heads; the list [1,2,3]
    ₇ḣ3  --call 2nd line with map overflow: [[],["","","Fizz"],["","","","","Buzz"]]
 ṁ!⁰₇ḣ3  --index the lambda argument to each list (modularly) and concat the results

And pulling it together:
m§Ysλṁ!⁰₇ḣ3)ḣ100
    λṁ!⁰₇ḣ3)      --"","Fizz","Buzz",or"FizzBuzz"
   s              --string representation of the number
 §Ysλṁ!⁰₇ḣ3)      --apply both and take max; "" < numeric strings < alphabet
m§Ysλṁ!⁰₇ḣ3)ḣ100  --map across [1,..,100]

Then Husk's default output style for an object of type [[TChar]] turns out to be just what we want.

This could have been -3 bytes if we didn't need to hardcode it for 100 lines! Ah well.

///, 198 bytes
/%/!"
//$/
"!//#/
Fizz"
//"/Buzz//!/
Fizz
/1
2!4$7
8%11!13
14#16
17!19$22
23%26!28
29#31
32!34$37
38%41!43
44#46
47!49$52
53%56!58
59#61
62!64$67
68%71!73
74#76
77!79$82
83%86!88
89#91
92!94$97
98!"

Try it online! Try it interactively!

Ada (GNAT), 298 bytes
with Ada.Text_IO;use Ada.Text_IO;procedure T is begin for I in Integer range 1..100 loop if I mod 15 = 0 then Put_Line("FizzBuzz");elsif I mod 3 = 0 then Put_Line ("Fizz");elsif I mod 5 = 0 then Put_Line ("Buzz");else Put_Line (Integer'Image (I)(2 ..Integer'Image(I)'Last));end if; end loop; end T;

Try it online!
Ungolfed:
with Ada.Text_IO;use Ada.Text_IO;

procedure Test is begin
    for I in Integer range 1 .. 100 loop
        if I mod 15 = 0 then
            Put_Line ("FizzBuzz");
        elsif I mod 3 = 0 then
            Put_Line ("Fizz");
        elsif I mod 5 = 0 then
            Put_Line ("Buzz");
        else
            Put_Line (Integer'Image (I)(2 .. Integer'Image(I)'Last));
        end if;
    end loop;
end Test;

Pretty vanilla, but I didn't see an Ada solution yet. Probably because Ada might just be the worst real-world language to golf with!

Ada isn't bad, it's more that hardly anyone even knows about it

Oh, I love Ada. It is definitely my favourite language. It just sucks for code golf. And yeah, I wish more people knew about it. :)

Well, it can't possibly be as bad as Java :P

also on your profile: "am familiar with a majority of commonly used programming languages". which ones exactly? :P

207

204

203

You should post that as a separate answer. I didn't abuse Ada2012 as much and forgot to be a child of I/O package. Take credit where its due :)

I already did :P and 2. I stole the idea from Lynn's Hello World actually

Groovy, 63 bytes
Stand-alone program, prints result to STDOUT.
100.times{n->s=(++n%3?'':'Fizz')+(n%5?'':'Buzz')
println s?s:n}

I'd have preferred to use (1..100).each{ instead of 100.times{, so that I didn't have to ++n at the start of each iteration, but this is golf and that saves me two bytes.
Other than that, a pretty standard truthy-based submission. 'Fizz' and 'Buzz' are added when remainder is 0 because 0 is falsy, and '' is a falsy string, so I can print n when the first line hasn't had either of 'Fizz' or 'Buzz' added.
Try it online!

Ink, 77 70 57 48 bytes
-(n){n%3:{n%5:{n}}|Fizz}{n%5: |Buzz}
{n<100:->n}

Try it online!

Brachylog, 48 bytes
100⟦₁{f{∋15∧"FizzBuzz"|∋3∧"Fizz"|∋5∧"Buzz"|t}ẉ}ᵐ

Try it online!
Probably not golfed too well but it works.

C, 98 94 bytes
i;main(){for(;++i<101;)i%3*i%5?printf("%d\n",i):printf("%s%s\n",i%3?"":"Fizz",i%5?"":"Buzz");}

Pretty simple stuff...
Thanks to Yoris Fresh for helping me save a couple bytes.
Thanks to Jerry Jeremiah for pointing out a mistake in the ungolfed version.
Ungolfed:
i;
main() {
    for (; ++i < 101;)
        i % 3 && i % 5 ?
            printf("%d\n",i) :
            printf("%s%s\n", i % 3 ? "" : "Fizz", i % 5 ? "" : "Buzz");
}

the ungolfed version increments i twice each loop.

Scheme, 118 bytes
(for-each(lambda(i)(printf"~a~a~%"(if(=(mod i 3)0)'Fizz"")(if(=(mod i 5)0)'Buzz(if(=(mod i 3)0)""i))))(cdr(iota 101)))

Try it online!
Ungolfed:
(for-each
 (lambda (i)
   (printf
    "~a~a~%"
    (if (= (mod i 3) 0) 'Fizz "")
    (if (= (mod i 5) 0) 'Buzz
        ;; else
        (if (= (mod i 3) 0) "" i))))
 (cdr (iota 101)))

05AB1E, 24 bytes
тÝ3Å€"Fizz"}5Å€á”ÒÖ”J}¦»

Try it online!
Explanation:
тÝ                  # range 0..100
  3Å€      }        # for every 3rd element...
     "Fizz"         # replace it with Fizz
  5Å€      }        # for every 5th element...
     á              # keep only letters...
      ”ÒÖ”J         # and append "Buzz"
            ¦       # drop the first element
             »      # join with newlines
                    # implicit output

Or alternatively:
тÝ35vyÅ€á”FizzÒÖ”#NèJ]¦»

Try it online!
35vy iterates over the digits of 35, which avoids repeating Å€}. ”FizzÒÖ” is the string Fizz Buzz, and then #Nè selects the appropriate element.
Legacy 05AB1E doesn’t have Å€, so neither of those work for it. However, legacy Ã (set intersection) implicitly splits numbers, which lets us get a 26 that only works on legacy:
тLεDÑ35Ãvá”Fizz ÒÖ”#yèJ},

Try it online!
тLε                         # for y in 1..100
   DÑ                       # divisors of y
     35Ã                    # keep only those in [3, 5]
        v               }   # for each...
         á                  # keep only letters
          ”Fizz ÒÖ”#yèJ     # append either Fizz or Buzz
                         ,  # print with newline

Pip, 43 41 bytes
Fa1,101{i:0a%3?i:1O"FIZZ"a%5?i?PaPxP"BUZZ"}
Lh{i:0o%3?i:1O"FIZZ"o%5?i?PoPxP"BUZZ"++o}

Try it online!

MineFriff, 240 bytes
0,`
>I1,+:a*a1,=?;`~             o,aC            <
>:f,%?`Ca*c2,:a*b7,7*e,a*c2,:f*7,a*7,oooooooo^
>:5,%?`Ca*c2,:a*b7,6*b,oooo                  ^
>:3,%?`Ca*c2,:f*7,a*7,oooo                   ^
>:o                                          ^

Try it online!
What it actually looks like:

It's.. beautiful.

Keg, 58 40+4 43 bytes
1(d|0&:3%[|`Fizz`,⑹]:5%[|`Buzz`,⑹]&[|:.]
,⑨

Try it online!
-14 bytes thanks to @EdgyNerd and then -1 byte due to using register
Answer History
58 bytes
1(d|:\“%0=[`FizzBuzz`|:5%0=[`Buzz`|:3%0=[`Fizz`|:⅍]]],
,⑨)

Try it online!
String compression and string formatting are both useless here. Just a standard implementation of Fizzbuzz in Keg.

Idea to golf some bytes: couldn't you push an empty string, and then concatenate 'Fizz' if it's a multiple of 3, and then concat 'Buzz' if it's a multiple of 5, to save the FizzBuzz in your code (and probably some other bytes)

Python 3, 80 bytes
for x in range(1,101):print(("Fizz"if x%3==0else"")+("Buzz"if x%5==0else"")or x)

MC6000 ASM (Shenzhen I/O), 133 Bytes
add 1
mov acc x3
mov 51 x2
mov acc x2
mov 3 x2
teq x2 0
+mov 1 x1
mov 51 x2
mov acc x2
mov 5 x2
teq x2 0
+mov 2 x1
slp 1
mov -999 x1

Uses an MC4010 co-processor on x2, numeric display on x3, and a custom fizzbuzz display on x1.
"Hardware":

Custom LCD:

Technically doesn't follow the rules as MCxxxx don't have a STDOUT, but I did the best I could.

W d, 29 23 bytes
&ó╞╟↨5O╓46N☻»½_49ƒZÄ▬«Σ

A raw source is here.
After decompression:
2^                         E % Foreach in the 1..100 range
        a3m!                 % If the current item is divisible by 3:
  "Fizz"    *                % Return "Fizz"
             "Buzz"a5m!*     % If the current item | 3 -> "Buzz".
                        +    % Join those results
                         a|  % Logical OR this result with the current item
                              % Implicit print

Javascript 78 (but kinda 58) bytes
Produces the required string, then prints it. The function that produces the string is 58 bytes, another 20 are used to call console.log.
z=n=>n?z(n-1)+((n%3?'':'Fizz')+(n%5?'':'Buzz')||n)+'\n':'';console.log(z(100))

Javascript 72 71 bytes (thanks, Jo King!)
Prints the required lines as it goes. Interweaving console.log with the logic creates a shorter, though less elegant, program.
z=n=>n&&(z(n-1),console.log((n%3?'':'Fizz')+(n%5?'':'Buzz')||n));z(100)

It can also be written like the following, to the same effect and byte count.
z=n=>n&&console.log((z(n-1),(n%3?'':'fizz')+(n%5?'':'buzz')||n));z(100)

De-golfed version:
z = n =>           // take n as argument
  n && (           // if n is not falsey (e.g. if it is not 0)
    z(n-1),        // use the comma operator to call the previous fizzbuzz
    console.log(   // then print a line
      (n%3 ? '' : 'Fizz')   // 'Fizz' if n is a multiple of 3, otherwise empty
      + (n%5 ? '' : 'Buzz') // Concatenated with 'Buzz' if multiple of 5
      || n         // Or just the number n if the previous string is empty, which implies that n is not divisible by 3 or 5
    )
  );
z(100)             // Run fizzbuzz from 100

You can save 5 bytes (on every solution) by using alert instead of console.log

APL, 52 chars/bytes
generate integers from 1 to n
⍳

b is a 2 by n boolean matrix highlighting multiples of 3 and 5
b←0=3 5∘.|⍵

c is a boolean vector highlighting multiples of either 3 or 5
c←∨⌿b

format each integer into a character vector
⍕¨⍵

where a number is a multiple of either 3 or 5...
@{c}

...put either Fizz or Buzz (i.e. discard the last 4, the first 4 or no character at all from the string "FizzBuzz" according to b)
(↓∘'FizzBuzz'¨¯4 4+.×c/b)

transform the nested vector into a matrix
↑

https://tio.run/##SyzI0U2pTMzJT////1Hf1EdtE6qTgcSjjhWPevYnAVkGtsYKpo86ZujVPOrd@qi75VHbRI1HbZOBIupumVVVTqVVVeqHVhxab6Jgoq13eHqyfpKmQ3Vy7aPeqYdWAHUAGZsNDQz@/wcA

sed 4.2.2, 129 bytes
A 400-rep bounty for those who outgolf this solution https://codegolf.meta.stackexchange.com/a/18428/
s/^/00,/;h
:
y/0123456789';,/1234567890;,'/
/0.$/!{x;G;s/..\n.//}
h
s/[05].$/&Buzz/
s/.*,/Fizz/
s/.*\WB/B/
s/[0';]*//gp
g;/00/d
t

Try it online!
s/^/00,/;h

Each number is stored as three characters, the first two store the two-digit padded decimal number, and the last character stores its modulo 3.
: ... t

In a loop,
y/0123456789';,/1234567890;,'/

the modulo is cycled, and the number is incremented using transliteration. Each digit is increased modulo 10, then
/0.$/!{x;G;s/..\n.//}

a simple conditional corrects the first digit on the number if necessary, using the fact each number is stored with exactly 3 characters.
h

This incremented form is stored in the hold space.
s/[05].$/&Buzz/

Buzzs are added by looking at the last base-10 digit of the number.
s/.*,/Fizz/

Fizzs are added by looking at the modulo-3.
s/.*\WB/B/

There is some cleanup of the number, remove the base-10 digits if needed and
s/[0';]*//gp

remove leading 0s and the modulo-3 so that it is print-ready, and print it.
g;/00/d

Finally retrieve the number from the hold space and exit if 00 is present, i.e. 100 has been reached

Rust, 114 bytes
It's not the shortest one available (on code-golf.io someone managed to somehow solve it in 99 bytes, but I have no idea how).
fn main(){(1..101).for_each(|i|println!("{}",["FizzBuzz","Fizz","Buzz",&i.to_string()][1.min(i%5)+2.min(i%3*2)]))}

First off, the obvious part
fn main() {/*..*/}

Then we iterate from 1 to 100 (inclusive) and println! an element of the array
(1..101).for_each(|i| println!("{}", ["FizzBuzz", "Fizz", "Buzz", &i.to_string()][/*..*/]))

To choose the right index, we use the following, where i is the current number
1.min(i % 5) + 2.min((i % 3) * 2)

The first part is 0 if i is a multiple of 5. Otherwise it's 1.
The second part is 0 if i is a multiple of 3. Otherwise it's 2.
Examples:
1.min(1 % 5) + 2.min((1 % 3) * 2) == 1 + 2 == 3 => "1"
1.min(3 % 5) + 2.min((3 % 3) * 2) == 1 + 0 == 1 => "Fizz"
1.min(4 % 5) + 2.min((4 % 3) * 2) == 1 + 2 == 3 => "4"
1.min(5 % 5) + 2.min((5 % 3) * 2) == 0 + 2 == 2 => "Buzz"
1.min(15 % 5) + 2.min((15 % 3) * 2) == 0 + 0 == 0 => "FizzBuzz"

This way, if both parts produce 0, we get the string FizzBuzz.
If the sum is 1 we get Fizz, if it's 2 Buzz, if it's 3 we get &i.to_string() (the stringified number).

You can replace println! with print! and add a literal (as in press ENTER/RETURN) newline after the {} in the format string to save a byte. Also, if you're allowed to use a closure, it'd save quite a few bytes over using fn main(). Finally, you save some bytes using a for loop. 99 bytes: TIO

I have a different solution. What I did was I merged mine with yours (your logic and my loop) and got 108 bytes: fn main(){for i in 1..101{print!("{} ",["FizzBuzz","Fizz","Buzz",&i.to_string()][1.min(i%5)+2.min(i%3*2)])}}   -   Try it online!

It's 94 bytes now :3

Stax, 27 bytes
éeO├φ☻mRàzΦ╛`φ#2àáÿ²øΔ=L←§b

Run and debug it
Unpacked and Uncompressed
A2#F~;3%z"Fizz"?;5%z"Buzz"?+cz=,a?P

International Phonetic Esoteric Language, 61 60 bytes
{2T}1ɑeb3ⱱɐbʌɔ|a|"Fizz"u|a|q5ⱱɐbʌɔ|b|"Buzz"u|b|ɞʌue1sø"\n"uɒ

Explanation:
{2T}1                                                        (push loop bounds 1 to 2T == 101 base36)
     ɑ                                                       (start loop)
      eb                                                     (push and dup loop index)
        3ⱱɐbʌɔ|a|"Fizz"u|a|                                  (print if fizzy)
                           q                                 (OVER)
                            5ⱱɐbʌɔ|b|"Buzz"u|b|              (print if buzzy)
                                               ɞʌu           (else print the number)
                                                  e1sø       (increment loop index)
                                                      "\n"u  (print a newline)
                                                           ɒ (end loop)

-1 byte for using base 36 for 101.

MAWP, 120 bytes
[!!3P3WA<75W2W;73W5W;65W2W1M2W;65W2W1M2W;~0~>%!!5P5WA<92M6W;94M9W;65W2W1M2W;65W2W1M2W;~0~>%~{~!:~}~!554WWA?.%1M25W;~(%)]

Try it!
Created this while testing my new online interpreter!
Explanation:
[                                              Start loop
!!3P3WA                                        Is divisible by 3? (Homemade modulo
                                               function)
<                                              If top of stack is not 0 (number is
                                               not divisible), then jump to its >
75W2W;73W5W;65W2W1M2W;65W2W1M2W;               Print 'Fizz'
~0~                                            Add 0 to the bottom of stack by
                                               double reversing
>                                              End conditional
%                                              Remove modulo function result
!!5P5WA<92M6W;94M9W;65W2W1M2W;65W2W1M2W;~0~>%  Do the same for 'Buzz'
~                                              Reverse stack
{                                              If there are no 0 on the top of
                                               stack (not 'Fizz' nor 'Buzz' was
                                               printed),
~!:~                                           then print the current number
}~                                             End conditional and reverse stack
!554WWA?.%                                     If the number is 100, then terminate
                                               program
1M25W;                                         Print newline
~(%)                                           Remove all 0 from bottom of stack
]                                              End of loop

Python 2, 73 77 bytes, link
edit:
Even shorter, thanks to @Dingus + removing parenthesis:
for n in range(1,101):print[[n,"Buzz"],["Fizz","FizzBuzz"]][n%3<1][n%5<1]

original:
Here's my matrix-inspired approach:
for n in range(1,101):
    print([[n,"Buzz"],["Fizz","FizzBuzz"]][n%3<1][n%5<1])

It avoids double checking modularity for 15. Written out a bit more elaborately, this becomes
for n in range(1,101):
    matrix=[[n     ,"Buzz"    ],
            ["Fizz","FizzBuzz"]]

    print(matrix[n%3==0][n%5==0]) # checking ==0 adds 1 byte versus <1.

Welcome to the site, and nice first answer! You might like to include a link to Try It Online (TIO). It seems you can save 2 bytes by putting all your code on one line.

Thank you @Dingus for the encouragement and improvement. I also removed the parenthesis since it's Python 2.

LiveScript, 57 bytes
I noticed nobody had done LiveScript.
This may not be the shortest possible answer, but it's my best attempt.
for i to 99
 console.log \Fizz *!(++i%3)+\Buzz *!(i%5)||i

MAWP 2.0, 60 bytes
[!3%<"Fizz":1=M>`!5%<"Buzz":1=M>`M1-{/!:\}`0=M10;!100-?.`1+]

Explanation:
[                start of loop
!3%              is top of stack divisible by 3?
<"Fizz":1=M>`    if yes, print "Fizz" and set variable M to 1
!5%              is top of stack divisible by 5?
<"Buzz":1=M>`    if yes, print "Buzz" and set variable M to 1
M1-              push value of M and subtract 1
{/!:\}`          if not 0 then print the current number
0=M              set variable M to 0
10;              print a newline
!100-?.`         if current number is 100 then terminate program
1+               add 1 to current number
]                end of loop

Charcoal, 37 29 bytes
Ｅ…¹¦¹⁰¹∨⁺×Fizz¬﹪ι³×Buzz¬﹪ι⁵Ｉι

Try it online!
How there isn't a charcoal answer yet amazes me. -8 bytes thanks to @Neil
Verbose

There are other minor variants such as Print(Map(100, Or(Add(Ternary(Modulo(Incremented(i), 3), "", "Fizz"), Ternary(Modulo(Incremented(i), 5), "", "Buzz")), Cast(Incremented(i))))); also for 29 bytes, but I do have a 28 byte solution...

I guess it's about time I reveal my 28 byte solution: Ｅ¹⁰⁰∨⭆⪪FiBu²⎇﹪⊕ι⁺³⊗μω⁺λzzＩ⊕ι.

Add++ -i, 46 bytes
L,100Rdd3€Ω%€!"Fizz"€*$5€Ω%€!"Buzz"€*z£+z£obUn

Try it online!
The flag simply invokes the function for us and outputs its return value, so we don't have to include the invocation in the program.
How it works
L,			; Anonymous function
	100R		; Push [1 2 3 4 ... 99 100]		STACK = [[1 2 ... 99 100]]
	dd		; Triplicate				STACK = [[1 2 ... 99 100] [1 2 ... 99 100] [1 2 ... 99 100]]
	 €  €		; Over the first, check ...
	3 Ω% !		;    divisibility by 3			STACK = [[1 2 ... 99 100] [1 2 ... 99 100] [0 0 ... 1 0]]
	"Fizz"€*	; Replace 1 with "Fizz" and 0 with ""	STACK = [[1 2 ... 99 100] [1 2 ... 99 100] ["" "" ... "Fizz" ""]
	$ €  €		; Over the second, check ...
	 5 Ω% !		;     divisibility by 5			STACK = [[1 2 ... 99 100] ["" "" ... "Fizz" ""] [0 0 ... 0 1]]
	"Buzz"€*	; Replace 1 with "Buzz" and 0 with ""	STACK = [[1 2 ... 99 100] ["" "" ... "Fizz" ""] ["" "" ... "" "Buzz"]]
	z£+		; Zip and concatenate			STACK = [[1 2 ... 99 100] ["" "" ... "Fizz" "Buzz"]]
	z£o		; Replace "" with the right number	STACK = [[1 2 ... "Fizz" "Buzz"]]
	bUn		; Join with newlines			STACK = ["1\n2\nFizz\n...\n98\nFizz\nBuzz"]
			; Return the top of the stack		"1\n2\nFizz\n...\n98\nFizz\nBuzz"

Add++, 89 bytes
l:100
Fl,`f,i%3,f=0,"Fizz"*f,`b,i%5,b=0,"Buzz"*b,`p,f+b,p="",Ip,,Oi,`c,f+b,`P,p=0,IP,,Oc,

Try it online!
"But there's a shorter Add++ answer" I hear you say.
Well, this is flagless and doesn't have a Lambda, so I'd thought I'd post it for comparison.

AppleSoft BASIC, 112 bytes
0A$(1)="FIZZ":A$(2)="BUZZ":A$(3)="FIZZBUZZ":FORN=1TO100:A$(0)=STR$(N):?A$((N/3=INT(N/3))+(N/5=INT(N/5))*2):NEXT

Verified on https://www.calormen.com/jsbasic/

Forth (gforth), 95 bytes
: f 'e 1 DO 1 i 3 mod 0= if ." Fizz"0 then i 5 mod 0= if ." Buzz"0 then if i . then cr LOOP ; f

Try it online!
With help from @Bubbler, it's shorter than the other forth answer. Explanation coming soon.

!@#$%^&*()_+, 378 bytes
No TIO link, since the language has been updated to include the = command.
^!!($!!!!(!_++_^^^_$_^_$!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_++!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_+++!!_+^_$+_)+!!_+^$!!_+$(+$_^_$!!_+)+!_++$!_++(zziF@@@@ &!_+%!_+)+!!(!_++_^^^^^_$_^_$!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_++!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_+++!!_+^_$+_)+!!_+^$!!_+$(+$_^_$!!_+)+!_++$!_++(zzuB@@@@ &!_+%!_+)+ &($!#$!_+)
@^%$!_++!d_+!!_+^$!!_+$(+$_^_$!!_+)+!_++!!_+^_$+_$^$)

There are unprintables in this code. Here's an xxd dump:
00000000: 5e21 2128 2421 2121 2128 215f 2b2b 5f5e  ^!!($!!!!(!_++_^
00000010: 5e5e 5f24 5f5e 5f24 2121 5e5e 5f2b 3d21  ^^_$_^_$!!^^_+=!
00000020: 215f 2b5e 2421 215f 2b24 282b 245f 5e5f  !_+^$!!_+$(+$_^_
00000030: 2421 215f 2b29 2b21 5f2b 2b21 215e 5e5f  $!!_+)+!_++!!^^_
00000040: 2b3d 2121 5f2b 5e24 2121 5f2b 2428 2b24  +=!!_+^$!!_+$(+$
00000050: 5f5e 5f24 2121 5f2b 292b 215f 2b2b 2b21  _^_$!!_+)+!_+++!
00000060: 215f 2b5e 5f24 2b5f 292b 2121 5f2b 5e24  !_+^_$+_)+!!_+^$
00000070: 2121 5f2b 2428 2b24 5f5e 5f24 2121 5f2b  !!_+$(+$_^_$!!_+
00000080: 292b 215f 2b2b 2421 5f2b 2b28 7a7a 6946  )+!_++$!_++(zziF
00000090: 4040 4040 0026 215f 2b25 215f 2b29 2b21  @@@@.&!_+%!_+)+!
000000a0: 2128 215f 2b2b 5f5e 5e5e 5e5e 5f24 5f5e  !(!_++_^^^^^_$_^
000000b0: 5f24 2121 5e5e 5f2b 3d21 215f 2b5e 2421  _$!!^^_+=!!_+^$!
000000c0: 215f 2b24 282b 245f 5e5f 2421 215f 2b29  !_+$(+$_^_$!!_+)
000000d0: 2b21 5f2b 2b21 215e 5e5f 2b3d 2121 5f2b  +!_++!!^^_+=!!_+
000000e0: 5e24 2121 5f2b 2428 2b24 5f5e 5f24 2121  ^$!!_+$(+$_^_$!!
000000f0: 5f2b 292b 215f 2b2b 2b21 215f 2b5e 5f24  _+)+!_+++!!_+^_$
00000100: 2b5f 292b 2121 5f2b 5e24 2121 5f2b 2428  +_)+!!_+^$!!_+$(
00000110: 2b24 5f5e 5f24 2121 5f2b 292b 215f 2b2b  +$_^_$!!_+)+!_++
00000120: 2421 5f2b 2b28 7a7a 7542 4040 4040 0026  $!_++(zzuB@@@@.&
00000130: 215f 2b25 215f 2b29 2b00 2628 2421 2324  !_+%!_+)+.&($!#$
00000140: 215f 2b29 0a40 5e25 2421 5f2b 2b21 645f  !_+).@^%$!_++!d_
00000150: 2b21 215f 2b5e 2421 215f 2b24 282b 245f  +!!_+^$!!_+$(+$_
00000160: 5e5f 2421 215f 2b29 2b21 5f2b 2b21 215f  ^_$!!_+)+!_++!!_
00000170: 2b5e 5f24 2b5f 245e 2429                 +^_$+_$^$)

Alternatively, here's a version with no unprintables (387 bytes):
^!!($!!!!(!_++_^^^_$_^_$!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_++!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_+++!!_+^_$+_)+!!_+^$!!_+$(+$_^_$!!_+)+!_++$!_++(zziF@@@@!!_+&!_+%!_+)+!!(!_++_^^^^^_$_^_$!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_++!!^^_+=!!_+^$!!_+$(+$_^_$!!_+)+!_+++!!_+^_$+_)+!!_+^$!!_+$(+$_^_$!!_+)+!_++$!_++(zzuB@@@@!!_+&!_+%!_+)+!!_+&($!#$!_+)
@^%$!_++!d_+!!_+^$!!_+$(+$_^_$!!_+)+!_++!!_+^_$+_$^$)

Notes
There's likely still room for golfing. I decided to approach this by manually calculating mod 3 and mod 5 for each integer from 1 to 100, whereas an approach by maintaining separate counters for mod 3 and mod 5 might save tons of bytes. This was more of a proof of concept.
I made this snippet using a templating language of my own creation, which I will publish at some point. Here's the metaprogram:
;let ~ !!_+^$!!_+$(+$_^_$!!_+)+!_++
;let DROP !_++
;let omx !!_+^_$+_
^
!!
(
    $
    !!
    !!(
        DROP
          _ 3{^} _
        $ _ 1{^} _
        $

        -2=~-2=~+ omx
    )+~$DROP
    (
        @"Fizz"

        0&!_+%

        !_+
    )+
    !!(
        DROP
          _ 5{^} _
        $ _ 1{^} _
        $

        -2=~-2=~+ omx
    )+
    ~$DROP
    (
        @"Buzz"
        0&!_+%
        !_+
    )+

    0& ($!#$!_+)

    10@

    ^%
    $ DROP !
    -100 +~omx
    $^$
)

JavaScript, 69 68 bytes

-1 byte: inspired by this answer

for(i=0;++i<101;)console.log(i%3?i%5?i:"Buzz":i%5?"Fizz":"FizzBuzz")
In a readable form:
for (i = 0; ++i < 101; ) { // iterates from 1 to 100
  console.log(
    i % 3 != 0
      ? i % 5 != 0            // if i is not divisible by 3 ...
        ? i                     // ... and not divisible by 5, print i
        : "Buzz"                // ... but divisible by 5, print Buzz
      : i % 5 != 0            // if i is divisible by 3 ...
        ? "Fizz"                // ... but not divisible by 5, print Fizz
        : "FizzBuzz"            // ... and divisible by 5, print FizzBuzz
  )
}

Omit all  != 0 comparison and unnecessary whitespaces.

Welcome to the site, and nice first answer! Be sure to check out our Tips for golfing in Javascript page for more ways you could golf your answer.

Java 94 92 91 Bytes (loop without class declaration or main function) by Alex North
small optimizations by Alexander Lemieux
first the fully golfed/optimized code (the best I could do)
for(int i=0;i++<100;System.out.println(i%3<1|i%5<1?(i%3<1?"fizz":"")+(i%5<1?"buzz":""):i));

for reference here is what he posted to wiki.c2
(exactly copied and pasted from there)
for(int i = 0; i < 100; i++, System.out.println(i % 3 == 0 || i % 5 == 0 ? ((i % 3) == 0 ? "fizz" : "")

first I removed all of the spaces and changed the logical "or" to a bitwise "or" (changed || to |)
for(int i=0;i<100;i++,System.out.println(i%3==0|i%5==0?((i%3)==0?"fizz":"")+((i%5)==0?"buzz":""):i));

then I changed i%3==0 and i%5==0 to i%3<1 and i%5<1 ( I also removed unnecessary parenthesis),
for(int i=0;i<100;i++,System.out.println(i%3<1|i%5<1?(i%3<1?"Fizz":"")+(i%5<1?"Buzz":""):i));

lastly, I changed the loop from
(int i=0;i<100;i++)

to
(int i=0;i++<100;)

how it works
for(int i=0;i++<100;

regular java for loop
System.out.println(

print statement
(i%3<1|i%5<1?(i%3<1?"Fizz":"")+(i%5<1?"Buzz":""):i));

this is a little more complicated, it's roughly equivalent to the pseudo code:
if i is evenly divisible by 3 or 5
then
if i is evenly divisible by 3
then "Fizz"
+
if i is evenly divisible 5
then "Buzz"
else i
hope that wasn't too confusing.
THIS IS NOT MY CODE, I JUST CHANGED A FEW CHARACTERS, ALL CREDIT SHOULD GO TO ALEX NORTH!
my current best for FizzBuzz using java is 94 characters that can be found here
I did this because I thought his code deserved to be shown off because it is a smart solution.

Retina, 47 bytes

100*
L$`_
$.>`
4,5,m`^
Buz
2,3,m`^
Fiz
z\d*
zz

Try it online! Explanation: Much simpler than @MartinEnder's approach, although I did copy his zz trick to save two bytes.

100*
L$`_
$.>`

List the numbers from 1 to 100.
4,5,m`^
Buz

Prefix Buz to every fifth number.
2,3,m`^
Fiz

Prefix Fiz to every third number.
z\d*
zz

Double the zs, and also delete the number after Fizz or Buzz.

Factor, 145 142 122 bytes
As usual, @Bubbler nailed it. Go upvote one of his answers!
100 [1,b] [ dup [ 3 mod 0 = dup [ "Fizz"write ] when ] [ 5 mod 0 = dup [ "Buzz"write ] when ] bi or [ nl ] [ . ] if ] each

Try it online!
Old version:
1 [ dup 100 > ] [ dup [ 3 mod 0 = dup [ "Fizz"write ] when ] [ 5 mod 0 = dup [ "Buzz"write ] when ] bi or [ ""print ] [ dup . ] if 1 + ] until

Try it online!
Amazingly, until now no one posted a Factor answer.
It is not really golfed much, probably can be improved.

Nice try. Some quick golfing: you can replace the explicit loop with a range and each, like 100 [1,b] [ ... ] each. nl is a shorter alternative to ""print. 122 bytes

@Bubbler Thanks. I was looking for newline word but couldn't find it. I find the wealth of words a bit overwhelming, and some things are well hidden in the help system of Factor. Is there a document with all/most of the available words somewhere?

Everything can be found on the online docs, but it isn't easy to find the words you want either (mainly because it only searches for names, not content).

Burlesque, 72 bytes
,1 100r@{JJ3.%0=="Fizz"j.*j5.%0=="Buzz"j.***Jr&0=={vv}j{jvv}jie}m[\[Sush

Try it online!
Do you see that at the end? Sus?!? Does that mean this program is the impostor!!!
This is why I need to stop fizzbuzzing at 10pm at night. I'll explain this tomorrow if I remember how it works.

C#, 97 bytes
for(int x=0;x++<100;)System.Console.WriteLine(x%3*x%5>0?x+"":"FizzBuzz"[x%5>0?..4:x%3>0?4..:..]);

Requires C# 9 for top level statements and range syntax.

Dash, with these restrictions

with SUSv2-compatible utilities
no built-in loops, no built-in branches, no variables
1 pipeline
no awk
no LF in pattern space in sed
no hold space in sed

Dash, 103 bytes, 5 utilities.
echo ,,fizz,,buzz,fizz,,,fizz,buzz,,fizz,,,fizzbuzz|sed -n ':x
p
bx'|tr , \\n|sed '/./b
=
d'|head -n100

Try it online!
Dash, 124 121 bytes, 9 utilities.
echo xx|sed -n ':x
p
bx'|sed s/\$/fizz/|tr x \\n|paste - - - - -|sed s/\$/buzz/|tr \\t \\n|sed -n '/./p
/^$/='|head -n100

Try it online!
Dash, 133 132 bytes, 10 utilities.
echo|sed -n ':x
p
bx'|paste - - -|sed s/\$/fizz/|tr \\t \\n|paste - - - - -|sed s/\$/buzz/|tr \\t \\n|sed -n '/./p
/^$/='|head -n100

Try it online!
Originally, on GitHub Gist
With comments
echo | sed -n '
    :x
    p
    bx
' | # yes ''
paste - - - | sed s/\$/fizz/ | tr \\t \\n | # if NR%3==0; then $0="fizz";
paste - - - - - | sed s/\$/buzz/ | tr \\t \\n | # if NR%5==0; then $0=$0 "buzz";
sed -n '
    /./p
    /^$/=' | # = is to output line number
head -n 100

You might want to put some of the stuff from your header into your body, since it's a bit long.

program is very sus

@Original^3VI It was my intention that I thought of such long code at first.

@tailsparkrabbitear I was talking about the Dash, xxx bytes, ... part, not your code. The headings are usually kept short-ish.

@Original^3 how about this?

@tailsparkrabbitear Looks good :)

Kotlin, 95 bytes
fun main(){(1..100).map{i->println(when(0){i%15->"FizzBuzz";i%3->"Fizz";i%5->"Buzz";else->i})}}

Try it Online!

Deadfish~, 3299 bytes
{iiiii}dc{dddd}ic{iiii}c{dddd}c{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iic{dddd}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiiic{dddd}dddddc{iiii}iiiiiic{dddd}ddddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiii}dcc{dddd}ic{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}dciic{dddd}dc{iiii}dciiic{dddd}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{ddddd}ddddddc{iiiii}iciiiiicc{{d}}{d}ddc{iiii}dciiiiic{dddd}ddddc{iiii}dciiiiiic{dddd}dddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}dc{i}ddc{ddddd}iiic{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}cc{dddd}c{iiii}cic{dddd}dc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiii}ciiiic{dddd}ddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}ciiiiiic{dddd}ddddddc{iiii}c{i}dddc{ddddd}iiic{iiiiii}c{iii}iiiiic{ii}dddcc{ddddd}ddddddc{iiiii}iciiiiicc{{d}}{d}ddc{iiii}icddc{dddd}ic{iiii}icdc{dddd}c{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}icic{dddd}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iciiiic{dddd}dddddc{iiii}iciiiiic{dddd}ddddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iicdddc{dddd}ic{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iicdc{dddd}dc{iiii}iicc{dddd}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{ddddd}ddddddc{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iiciic{dddd}ddddc{iiii}iiciiic{dddd}dddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiciiiiic{ddddd}iiic{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiicdddc{dddd}c{iiii}iiicddc{dddd}dc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iiicic{dddd}ddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiciiic{dddd}ddddddc{iiii}iiiciiiic{ddddd}iiic{iiiiii}c{iii}iiiiic{ii}dddcc{ddddd}ddddddc{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iiiicdddddc{dddd}ic{iiii}iiiicddddc{dddd}c{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiicddc{dddd}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiicic{dddd}dddddc{iiii}iiiiciic{dddd}ddddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iiiiicddddddc{dddd}ic{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiiicddddc{dddd}dc{iiii}iiiiicdddc{dddd}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{ddddd}ddddddc{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iiiiicdc{dddd}ddddc{iiii}iiiiicc{dddd}dddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiiiciic{ddddd}iiic{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiiiicddddddc{dddd}c{iiii}iiiiiicdddddc{dddd}dc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiii}iiiiiicddc{dddd}ddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiii}iiiiiicc{dddd}ddddddc{iiii}iiiiiicic{ddddd}iiic{iiiiii}c{iii}iiiiic{ii}dddcc{ddddd}ddddddc{iiiii}iciiiiicc{{d}}{d}ddc{iiiii}dddc{d}iic{dddd}ic{iiiii}dddc{d}iiic{dddd}c{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}dddcdddddc{dddd}ddc{iiiii}iiiiiic{iiiii}iciiiiicc{{d}}{d}ddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}dddcddc{dddd}dddddc{iiiii}dddcdc{dddd}ddddddc{iiiiii}c{iii}iiiiic{ii}dddcc{{d}}{d}ddc{iiiii}iiiiiic{iiiii}iciiiiicc

Oof.

Branch, 98 bytes
\^//C//70/105/122Z/zc\/66/117/z/za1O[/ob3^%Vc/v?[./]b5^%Wc\w?[./]a/vbw^*/0bo^?[#0]a10.o}O/;b101^-]

Try it on the online Branch interpreter!
Explanation
The first part basically loads "Fizz" and "Buzz" along the left branches of two trees, so it looks like:
          0
         / \
        0   0
       /|  / \
      F 0 B   0
     /   /
    i   u
   /   /
  z   z
 /   /
z   z

Then, start the value at 1. Each time, load the value to the left child and 3 to the right child, modulo, move that to the left fork, and branch on condition. If it's 0, it goes to the left branch with "Fizz" and otherwise to the right branch with just 0. [./] keeps printing as a character and moving to the left child so long as the value is not 0, so this prints "Fizz" if it's a multiple of three, and nothing happens otherwise.
Then, do the same thing but with 5 and move to the "Buzz" branch. Finally, load the results of both modulos (using registers to save and move these values) and multiply them. Loading 0 to the left child and the current value into the right branch, using ? on the product will go to the 0 if either modulo was 0, and to the value otherwise. Then, [#0] keeps outputting the value and zeroing it if it is not zero; in other words, if the modulo product was 0, it skips this, and otherwise, it outputs the current value as a number once.
Finally, output a newline, increment the current value, and check if it's high enough to end the program, and if so, exit the main loop.

PPL, 164 bytes
declarex=0
loop100{
x=x+1
ifx%15<1{
printLine("FizzBuzz")
}
ifx%3<1&&x%5>0{
printLine("Fizz")
}
ifx%5<1&&x%3>0{
printLine("Buzz")
}
ifx%3>0&&x%5>0{
printLine(x)
}
}

Yes... 164 bytes.
The problem with my language is that it's almost impossible to golf, because:

the newline is the only separator
all variables must be declared with the declare keyword
no shorthands like += or %=
no ternary operators
false is the only falsey value
long function name: printLine
no bitwise and

The good thing is that because of my sloppy lexer, we can mash together expressions. You would never see ifx%15<1 or loop100 in Python, for example. [it's not a bug, it's a feature ...?]There also happens to be no documentation for PPL at the moment.

It looks just like python.....

@Wasif you can say that :) but I didn't design it to look like python

Javastack, 145 bytes
100 range map 1 add duplicate 3 mod 0 equal "Fizz"swap repeat swap 5 mod 0 equal "Buzz"swap repeat swap add swap 1 add swap logicor end "\\n"join

Try it online!
-17 thanks to exedraj
-22 thanks to new mod builtin

Oh, nice. It's probably cheaper to use a for loop and print, instead of trying to join by newlines, but whatever, and I'm glad I made my  docs clear enough for you to understand.

I'll add it to DSO soonish...

167 bytes: 100 range map 1 add duplicate 3 divmod 1 index 0 equal "Fizz"swap repeat swap 5 divmod 1 index 0 equal "Buzz"swap repeat swap add swap 1 add swap logicor end "\\n"join

Python 3, 59 bytes
for i in range(100):print(i%3//2*'Fizz'+i%5//4*'Buzz'or-~i)

Dash and utils, 89 bytes
f(){ [ $((i%$1)) = 0 ]&&j=$2zz$j;};for i in `seq 100`;do(f 5 Bu;f 3 Fi;echo ${j-$i});done

Try it online!
As a bonus this is partially obfuscated, containing neither Fizz nor Buzz (even saved 2 bytes in doing so).
88 bytes (with caveats)
f(){(: $((0/(i%$1))))||j=$2zz$j;};for i in `seq 100`;do(f 5 Bu;f 3 Fi;echo ${j-$i});done

Try it online!
This solution was an attempt to reduce the bytes used by the conditional. In the end it saved only 1 byte, but it spams STDERR, which actually looks OK on TIO because it separates the streams. Even so I’m not sure it’s a proper solution due to the spam, but honestly I’m quite proud of the trickery involved.  We could suppress the errors with a redirect but that eats up precious bytes :)
EDIT: the trickery probably bears an explanation as the mechanism may not be immediately obvious.
Most of this explanation applies to the 89 byte, the only change is the conditional.
f(){

Define function f, easy enough.
(: $((0/(i%$1))))

This is the (most) sneaky bit
( begin a subshell, use : 'true' to perform some maths $(( in which we take 0 and divide / by the result of (i%$1), end the maths )) and end the subshell ).
This whole construct returns exit code 0 when the result of i % $1 is non-zero, otherwise it returns 1.
This works because when the i % $1 operation results in a zero we get a "division by zero" error terminating the subshell and causing it to return exit code 1.
This trumps the : "true" that the maths is running behind.
In all other instances we are taking zero and dividing it by a non-zero i % $1 result, which is obviously always zero by definition but the key thing is that it doesn't error the shell (thus the : stands) and from this we can catch the "division by zero" without the whole script bombing out.
||j=$2zz$j;};

Catch the error from the subshell via  || and set j= to the value of $2 appending zz (to complete our Fizzes and Buzzes) and prepending the whole thing to $j (the prepend action stems from an earlier iteration and only remains so because there's no advantage in making it an append.  Even more so now I've done this explanation), then just finish up the function ;};.
NB j lives and dies inside another subshell which calls this function, and is assumed to always start empty (but we'll get to that later).
for i in `seq 100`;do

As it appears, for loop through 1-100.
(f 5 Bu;f 3 Fi;echo ${j-$i})

The second (very mildly) sneaky part -- we start a subshell ( and for every number in the sequence, we call f twice.  Once each for the FizzBuzz numbers 5, 3 (to be used in the i % $1 statement) and the corresponding two prefix letters which get used in making j.  We then print the value of j or, if it's empty, insert the current $i value.
When we close the subshell, j gets reset to its starting value (empty, assuming we started in a clean room).
;done

Yes, I do believe we are.

XML + XSLT, 1282 635 bytes
output.xml
<?xml-stylesheet type="text/xsl" href="s.xsl"?><n></n>

s.xsl
<x:stylesheet version="1.0" xmlns:x="http://www.w3.org/1999/XSL/Transform"><x:output method="text" /><x:template match="n"><x:text>1
2
Fizz
4
Buzz
Fizz
7
8
Fizz
Buzz
11
Fizz
13
14
FizzBuzz
16
17
Fizz
19
Buzz
Fizz
22
23
Fizz
Buzz
26
Fizz
28
29
FizzBuzz
31
32
Fizz
34
Buzz
Fizz
37
38
Fizz
Buzz
41
Fizz
43
44
FizzBuzz
46
47
Fizz
49
Buzz
Fizz
52
53
Fizz
Buzz
56
Fizz
58
59
FizzBuzz
61
62
Fizz
64
Buzz
Fizz
67
68
Fizz
Buzz
71
Fizz
73
74
FizzBuzz
76
77
Fizz
79
Buzz
Fizz
82
83
Fizz
Buzz
86
Fizz
88
89
FizzBuzz
91
92
Fizz
94
Buzz
Fizz
97
98
Fizz
Buzz
</x:text></x:template></x:stylesheet>

Hardcoding it is shorter than doing it the fun way :(
So here's the old way for posterity
1282 bytes
output.xml
<?xml-stylesheet type="text/xsl" href="s.xsl"?><n><N>1</N><N>2</N><N>3</N><N>4</N><N>5</N><N>6</N><N>7</N><N>8</N><N>9</N><N>10</N><N>11</N><N>12</N><N>13</N><N>14</N><N>15</N><N>16</N><N>17</N><N>18</N><N>19</N><N>20</N><N>21</N><N>22</N><N>23</N><N>24</N><N>25</N><N>26</N><N>27</N><N>28</N><N>29</N><N>30</N><N>31</N><N>32</N><N>33</N><N>34</N><N>35</N><N>36</N><N>37</N><N>38</N><N>39</N><N>40</N><N>41</N><N>42</N><N>43</N><N>44</N><N>45</N><N>46</N><N>47</N><N>48</N><N>49</N><N>50</N><N>51</N><N>52</N><N>53</N><N>54</N><N>55</N><N>56</N><N>57</N><N>58</N><N>59</N><N>60</N><N>61</N><N>62</N><N>63</N><N>64</N><N>65</N><N>66</N><N>67</N><N>68</N><N>69</N><N>70</N><N>71</N><N>72</N><N>73</N><N>74</N><N>75</N><N>76</N><N>77</N><N>78</N><N>79</N><N>80</N><N>81</N><N>82</N><N>83</N><N>84</N><N>85</N><N>86</N><N>87</N><N>88</N><N>89</N><N>90</N><N>91</N><N>92</N><N>93</N><N>94</N><N>95</N><N>96</N><N>97</N><N>98</N><N>99</N><N>100</N></n>

s.xsl
<x:stylesheet version="1.0" xmlns:x="http://www.w3.org/1999/XSL/Transform"><x:output method="text" /><x:template match="n"><x:for-each select="N"><x:if test=".mod 3=0">Fizz</x:if><x:if test=".mod 5=0">Buzz</x:if><x:if test=".mod 3*.mod 5!=0"><x:value-of select="."/></x:if><x:text>
</x:text></x:for-each></x:template></x:stylesheet>

W...why did I do this to myself?
Example output (using Firefox + privacy.file_unique_origin = false):

Explaination
The XML
XSLT/XML doesn't (afaik) have a nice easy way of generating ranges...so I have to manually place all the numbers in tags so I can use for-each later on.
The XSLT
<x:stylesheet version="1.0"
    xmlns:x="http://www.w3.org/1999/XSL/Transform">
    <x:output method="text" />
    <x:template match="n">
        <x:for-each select="N">
            <x:if test=".mod 3=0">Fizz</x:if>
            <x:if test=".mod 5=0">Buzz</x:if>
            <x:if test=".mod 3*.mod 5!=0">
                <x:value-of select="."/>
            </x:if>
            <x:text>
</x:text>
        </x:for-each>
    </x:template>
</x:stylesheet>

PARI/GP, 58 bytes
for(i=1,100,print(if(i%3<1,Fizz,i%5,i,"")if(i%5,"",Buzz)))
Attempt This Online!

BQN (CBQN), 48 bytes
(•Out•Fmt<○≠◶⊣‿⊢·∾"Fizz"‿"Buzz"/˜0=3‿5|⊢)¨1+↕100

Attempt This Online!
Explanation
(...)¨1+↕100
        ↕100  ⟨ 0 1 2 ... 98 99 ⟩
      1+      ⟨ 1 2 3 ... 99 100 ⟩
(...)¨        Apply this function to each:

•Out•Fmt<○≠◶⊣‿⊢·∾"Fizz"‿"Buzz"/˜0=3‿5|⊢
                                         ⊢  The argument number
                                     3‿5|   Mod 3 and mod 5, in a list
                                   0=        Is each equal to 0? (1 if so, 0 if not)
                   "Fizz"‿"Buzz"            List containing "Fizz" and "Buzz"
                                 /˜          Repeat each a number of times equal to the
                                             corresponding number from the previous step
                 ·∾                         Join that list of strings together
    •Fmt                                     Cast the initial number to a string
                                             Apply this function to the stringified number
                                             and the FizzBuzz string:
        ○≠                                     Take the length of each
       <                                       Test if the first is less than the second
          ◶                                 If the result is 0,
            ⊣                               use the stringified number
             ‿⊢                             but if it's 1, use the FizzBuzz string
•Out                                        Print that string with a newline

Fig, \$25\log_{256}(96)\approx\$ 20.578 bytes
#jeFcdn3n5a@2'D&=g"'+D&=_

Try it online!
Take that, Lyxal. Not so bad now, is it? Only 0.5 bytes longer than Jelly, and 3.5 longer than legit Vyxal.
#jeFcdn3n5a@2'D&=g"'+D&=_
          a@2             # The range [1, 10^2]
        n5   '            # For every 5th item
              D&=g"       # Replace with the compressed string for "Buzz"
      n3           '      # For every 3rd item
                    +     # Prepend
                     D&=_ # The compressed string "Fizz"
  eF                      # Filter out
    cd                    # Digits
#j                        # Join on newlines

You should at least have a two-byte constant for 100, if not one byte

@Steffan an earlier version of Fig had the @ overload for numbers be ten to the power of, so @2 would have worked. Lemme reimplement that...

Pure Bash, 62+1=63 bytes
Filename is x, which is 1-byte penalty.
Outgolfed user100411's answer by one byte.
!
((++x%3))||Fizz
((x%5))||$_\Buzz
echo ${_:-$x}
((x>99))||. x

Try it online!
How it works
!                # invoke no command so $_ (last command's last argument) is reset
                 # First time: $_ was random string
((++x%3))||Fizz  # increase x. if x mod 5 is zero try to invoke Fizz
                 # if invoked $_ is Fizz
                 # ((expression)) is not a command
((x%5))||$_\Buzz # like previous but prefix $_
echo ${_:-$x}    # try to output $_ but if $_ is empty output $x
((x>99))||. x    # load myself if x is less than 100
                 # . x does not change $_

Functional(), 314 310 288 277 273 269 bytes
0,1,=,:,$,&,$(X,& >($(I,T(>(a,b,c,d),b d(0,I)(= a,a(=,1)b,a b(=,1)c,a b(c,d))))1))(:(T,&(a,b,c,d))(X(T(b(d,a c)($(S,T(W()1 b()0()1()1 0(= b)b(= b)>()0 1()> >()0 1()> > 0,0)),=(:(t,t(S,1)))(0,&()(u()>()0,:(W,T(>(a 1),W))a b c d >()0)))0,W()1()1()0()0)),:(u,&()(W a b c d

Try it online!
Try the 273B version online!
Try the 277B version online!
Try the 288B version online!
Try the 310B version online!
Try the 314B version online!
in a more readable form ( ommited last )s are added ):
0,1,=,:,$,&,
$(X,& >(
  $(I,T(
    >(a,b,c,d),
    b d (0,I)(= a,a(=,1)b,a b(=,1)c,a b(c,d))
  )) 1
))(
 :(T,&(a,b,c,d))(
  X(
   T(
    b(d,a c)(
     $(S,T(
       W() 1 b () 0 () 1 () 1 0 (= b) b (= b) > () 0 1 () > > () 0 1 () > > 0,
       0
     )),
     =(
      :(t,t(S,1))
     )(
      0,
      &()(
       u() > () 0,
       :(W,T(>(a 1),W)) a b c d > () 0
      )
     )
    ) 0,
    W() 1 () 1 () 0 () 0
   )
  ),
  :(u,&()(W a b c d))
 )
)

explanation
The key of this code is a executer func "X" like a pseudo Python code below;
def executer(f):
  def incrementer(a,b=0,c=0,d=0):
    f(a,b,c,d)
    nextf = nullf if b==1 and d==1 else incrementer
    # nullf is a function to do nothing
    nextf(1^a,a^b,(a&b)^c,(a&b&c)|d)

  incrementer(1)

Then, this realize a 10-length loop to evaluate f(1,0,0,0), f(0,1,0,0), f(1,1,0,0), ... , f(0,1,0,1) in this order.
The parameters a,b,c,d describe 4 bits of 1 thru 10 ( the lowest bit first ).
Thus, the rough structure of this code is a double loop with "X" like below;
X(
 T(
  X(
   T(
    ** main part
    * print Fizz or Buzz or FizzBuzz or the sequence number
    * and print a newline
   )
  ),
  ** post process
  * re-assign "u", a func to print the upper digit, for the next iteration
 )
)

"T" is a "function template" and acts like a synonym of "&(a,b,c,d)" ( a user function template with 4 parameters a,b,c,d ) due to the assignment with ":" at the 8th line.
In addition to "X" and "T", I implemented "W" and "S" func for output.
"W" is for bit-sequence output.  "W" returns "W" itself after printing bits so that "W 0 1 0 1 0 0 0 0" print a bit sequence ( a newline in this case ) continuously for example.  And "W" takes a parameter as a bit to print, but is improved, for compressing bit streams, to print two bits of 11 at a time with ">" .
"S" is for "Fizz" ( against parameter (x,1) ) or "Buzz" ( against parameters (x,0) ) output with "W".
Other function "u" and "t" are variable over the double loop.
"u" is for printing the lower 4 bits of the upper digits, and is re-assigned in the post process of the outer loop.
"t" acts as a 3 state register, which holds 0, 1 and "S", and is re-assigned with ":(t,t(S,1))" on every loop iteration.  When "t" is 0 or 1, it is re-assigned with 1 or "S" respectively.  And when "t" is "S", it is re-assigned with 0 as a return value of "S" after printing "Fizz".

Terse, 22 bytes
电让一3我5u"Fizz‘Buzz"死开】而

Try it here
A golfing language made by me.

Python, 580 bytes
Here's a version that pre-computes the FizzBuzz table and then just returns a slice, which would be useful if you're running a worldwide FizzBuzz service. It'd be more interesting in a language that has slices as a first-class construct. Either way, a very unoptimized implementation:
from typing import List

class FizzBuzz:
    def __init__(self, max_n=10**4):
        self.max_n = max_n
        self.data = [i for i in range(0, self.max_n)]
        for r in range(0, self.max_n, 3):
            self.data[r] = "Fizz"
        for r in range(0, self.max_n, 5):
            self.data[r] = "Buzz"
        for r in range(0, self.max_n, 15):
            self.data[r] = "FizzBuzz"

    def fizzBuzz(self, n: int) -> List[str]:
        if n > self.max_n or n < 1:
            return None  # Out of range, not permitted
        return self.data[1:n]

s = FizzBuzz()
print(s.fizzBuzz(100))
```

Welcome to Code Golf! This site is for competitive challenges, not general programming questions.This challenge has minimum code size as its goal, and isn't just asking for answerers to create a FizzBuzz program (however interesting it is) unless some effort has been made to optimize its size.

Miled, 143127 bytes
I don't know if a language in alpha is allowed, but here it is.
-16 by myself. Yes. I was dumb.
join "\n" map fn cS "x" <: if:: div 15 x "FizzBuzz" else if:: div 3 x "Fizz" else if:: div 5 x "Buzz" else ->str x :> ..= 1 100

TIO (read: Try It Offline)
A little note on this language: it's created by me. The current release is the first release of the language and it's still in alpha, so expect bugs. I haven't encountered any yet, so I think, maybe the best way to test it is to make more people use it! So if you find bugs, please report it. And I'm just a hobbyist with few coding experiences, so please give me advices. Thanks!

languages in alpha/heavy development are definitely allowed - the implementation defines the language, so the language here is Miled (alpha) (or whatever versioning system you choose). I submitted a fizzbuzz for a in-dev alpha esolang once and no one was upset that it was still in development, so people won't be upset with this answer too. You can also always update this answer as later versions of Miled are released. Anyhow, this esolang looks really cool and I look forward to seeing how it turns out! :)

Thunno N, \$35\log_{256}(95)\$ ≈ 28.80921 bytes
aSR1+eD3 5ZP%0="FizzBuzz"2APz*JD!?K

Attempt This Online! (not yet though)
Thought I'd try my usual approach in Thunno to see how it turned out.
Explained
aSR1+eD3 5ZP%0="FizzBuzz"2APz*JD!?K
aSR1+                               # The range [1, 100]
     e                              # To each item:
      D                             #   Duplicate it
       3 5ZP%                       #   [% 3, % 5]
             0=                     #   == 0
               "FizzBuzz"2AP        #   ["Fizz", "Buzz"]
                            z*      #   repeated element-wise
                              J     #   "".join
                               D!?K #   if that's empty, leave the original number
# The N flag, of course, joins the output on newlines

jq -nr, 43 bytes
Exploiting that out-of-bounds array access evaluates to null. Works with jq 1.5+
range(100)+1|["Fizz"][.%3]+["Buzz"][.%5]//.

Try it online!

Desmos, 244 bytes
a=\left[1...100\right]
b\left(m\right)=\operatorname{mod}\left(a,m\right)
c\left(n\right)=\left\{b\left(n\right)=0:1,0\right\}
\left(a,1\right)Fizzc\left(3\right)
\left(a,0\right)Buzzc\left(5\right)
\left(a,0\right)${a}b\left(3\right)b\left(5\right)

Ungolfed

a=\left[1...100\right] sets a to be [1,2,3,4...100]
b\left(m\right)=\operatorname{mod}\left(a,m\right) b(m)=mod(a,m)
c\left(n\right)=\left\{b\left(n\right)=0:1,0\right\}if b(n)=0,output 1,otherwise 0
\left(a,1\right)Fizzc\left(3\right)This is just points at (a,1) labeled with fizz, and opacity c(3)
\left(a,0\right)Buzzc\left(5\right) Same with Buzz
\left(a,0\right)${a}b\left(3\right)b\left(5\right) Points at (a,0) with label a, opacity b(3)b(5)

SAS 4GL, 84 (or 81 or 72 or 63) 100 (or 89? ) 110 bytes (or 104? or 88?) 133 bytes (or 120? or 111?) 142 bytes (or 129? or 120?) (out of game 82)

The code (short)

data;do n=1to 1e2;x=scan('Fizz FizzBuzz Buzz'!!n,mod(gcd(n,15),11)-2);put x;end;run;

The "human readable" code

data;
  do n = 1 to 1e2;
    x = scan('Fizz FizzBuzz Buzz'!!n, mod(gcd(n, 15), 11) - 2);
    put x;
  end;
run;

Explanation (for n=20):
data;
  do n = 1 to 20;
    g = gcd(n, 15);
    m = mod(g, 11) - 2;
    y = 'Fizz FizzBuzz Buzz' !! n;
    x = scan(y, m);
    put n= @10 g= @20 m= @30 y= @70 x=;
  end;
run;

Variables:

g from greatest common divisor function gets : 1,3,5,15,
m from modulo function gets: -1,1,3,2,
y gets: "Fizz FizzBuzz Buzz          n" for n,
x value is scanned from y on position m (negative m means "scan backward").

SAS Log printout:
n=1      g=1       m=-1      y=Fizz FizzBuzz Buzz           1        x=1
n=2      g=1       m=-1      y=Fizz FizzBuzz Buzz           2        x=2
n=3      g=3       m=1       y=Fizz FizzBuzz Buzz           3        x=Fizz
n=4      g=1       m=-1      y=Fizz FizzBuzz Buzz           4        x=4
n=5      g=5       m=3       y=Fizz FizzBuzz Buzz           5        x=Buzz
n=6      g=3       m=1       y=Fizz FizzBuzz Buzz           6        x=Fizz
n=7      g=1       m=-1      y=Fizz FizzBuzz Buzz           7        x=7
n=8      g=1       m=-1      y=Fizz FizzBuzz Buzz           8        x=8
n=9      g=3       m=1       y=Fizz FizzBuzz Buzz           9        x=Fizz
n=10     g=5       m=3       y=Fizz FizzBuzz Buzz          10        x=Buzz
n=11     g=1       m=-1      y=Fizz FizzBuzz Buzz          11        x=11
n=12     g=3       m=1       y=Fizz FizzBuzz Buzz          12        x=Fizz
n=13     g=1       m=-1      y=Fizz FizzBuzz Buzz          13        x=13
n=14     g=1       m=-1      y=Fizz FizzBuzz Buzz          14        x=14
n=15     g=15      m=2       y=Fizz FizzBuzz Buzz          15        x=FizzBuzz
n=16     g=1       m=-1      y=Fizz FizzBuzz Buzz          16        x=16
n=17     g=1       m=-1      y=Fizz FizzBuzz Buzz          17        x=17
n=18     g=3       m=1       y=Fizz FizzBuzz Buzz          18        x=Fizz
n=19     g=1       m=-1      y=Fizz FizzBuzz Buzz          19        x=19
n=20     g=5       m=3       y=Fizz FizzBuzz Buzz          20        x=Buzz

Remarks:

if you decide to uses F, B, and FB for Fizz, Buzz, and FizzBuzz it can be shortened to:

data;do n=1to 1e2;x=scan('F FB B'!!n,mod(gcd(n,15),11)-2);put x;end;run;

so 72, right? ;-)

The data; and run; are mandatory keywords of every SAS 4GL data step, so if you thinking only about the "working code" (and have in mind the previous remark) you could say 63 bytes, right? ;-) ;-)

Observation
I dare to say that "FizzBuzz" is equivalent with "BuzzFizz", after all if a number is divisible by "3 and 5" it is also divisible by "5 and 3", isn't it?
In such case it can be golfed to 81 bytes:
data;
  do n = 1 to 1e2;
    t='Fizz Buzz';
    x = scan(t!!t!!n, mod(gcd(n, 15), 11) - 2);
    put x;
  end;
run;

Until I get confirmation I'll keep it unofficial.

The 4th obsolete solution.

The code (short)

data;do n=1to 1e2;f=^mod(n,3);b=^mod(n,5);put n@(4*^(f+b))"Fizz"+(-4*^f)"Buzz"+(-4*^b)4*" ";end;run;

The "human readable" code

The Code:
data;
  do n=1to 1e2;

    f=^mod(n,3);
    b=^mod(n,5);

    put n@(4*^(f+b))"Fizz"+(-4*^f)"Buzz"+(-4*^b)4*" ";

  end;
run;

Process:

print n and overprint it with Fizz, Buzz or FizzBuzz if divisibility occurs by shifting text with @() operator.

Remarks:

if you decide to uses F, B for Fizz and Buzz it can be shortened to:

data;do n=1to 1e2;f=^mod(n,3);b=^mod(n,5);put n@(4*^(f+b))"F"+(-^f)"B"+(-^b)"  ";end;run;

so 89, right? ;-) ;-)

"Out-of-game 82"
This example "breaks" the rule because it uses F, B and X instead full words, that is why I only puts it as a interesting case. It is a variation on the cycle string idea. And I like it the most :-)
The code:
data;do n=1 to 100;x=coalescec(char("X  F BF  BF B",mod(n,15)+1),n);put x;end;run;

Human readable:
data;
  do n = 1 to 100;
    x = coalescec(char("X  F BF  BF B", mod(n, 15) + 1), n);
    put x;
  end;
run;

If you will to create a SAS format:
proc format;
 value $ X (default=20)
 "F" = "Fizz"
 "B" = "Buzz"
 "X" = "FizzBuzz"
 ;
run;

and modify the put statement to:
put x $X.;

you will see "full words" in the log.

The 3rd obsolete solution.

The code (short)

data;do n=1to 100;x=ifc(mod(n,5)*mod(n,3),n,ifc(^mod(n,5),"Fizz","")!!ifc(^mod(n,3),"Buzz",""));put x;end;run;

The "human readable" code

The Code:
data;
  do n = 1 to 100;
    x =                       /* create variable x and... */
        ifc(mod(n,5)*mod(n,3) /* if n not divisible by 3 or 5 */
            ,n                /* assign n to x, else... */
            ,ifc(^mod(n,5)    /* if divisible by 5 add Fizz string to x */
                 ,"Fizz"
                 ,"")
             !!               /* and concatenate with... */
             ifc(^mod(n,3)    /* if divisible by 5 add Buzz string */
                 ,"Buzz"
                 ,"")
             );
    put x ;                   /* print value from x variable */
  end;
run;

Comments:

It looks like "concatenation" of four mod(.,.) functions and three ifc() functions do the job even better.

Remarks:

If the Fizz and Buzz phrases could be "replaced" by F and B the code would be 6 bytes shorter, that's why I wrote 104 in brackets. :-)
The data; and run; are mandatory keywords of every SAS 4GL data step, so if you thinking only about the "working code" (and have in mind the previous remark) you could say 95 bytes, right? ;-) ;-)

The 2nd obsolete solution.

The code (short)

data;do n=1to 100;select;when(^mod(n,15))put"FizzBuzz";when(^mod(n,5))put"Fizz";when(^mod(n,3))put"Buzz";otherwise put n;end;end;run;

The "human readable" code

The Code:
data;
  do n = 1 to 100;
    x = ifc(mod(n,5)*mod(n,3)
            ,n
            ,ifc(^mod(n,5)
                 ,"Fizz"
                 ,"")
             !!
             ifc(^mod(n,3)
                 ,"Buzz"
                 ,"")
             );
    put x ;
  end;
run;

Comments:

It looks like doing 3 times "negated modulo" (^mod(.,.)) takes less keystrokes than previous "cycle string" approach.

Remarks from the previous one stay, but with 120 and 111 accordingly. ;-) ;-)

The 1st obsolete solution.

The code (short)

data;do n=1to 100;select(char("300102100120100",mod(n,15)+1));when(0)put n;when(1)put"Fizz";when(2)put"Buzz";when(3)put"FizzBuzz";end;end;run;

The "human readable" code "step by step"

The Code:
data;
  do n = 1 to 100;

    select( char( "300102100120100", mod(n, 15) + 1) );
      when(0) put n;
      when(1) put "Fizz";
      when(2) put "Buzz";
      when(3) put "FizzBuzz";
    end;

  end;
run;

The process:

the do n = 1 to 100; makes the loop from 1 to 100, so if you want to play FizzBuzz for 1000 it is just 1 extra byte cost,
"300102100120100" - the "cycle string" - when you realise the divisibility by 3 or 5 is cyclic modulo 15 you will see all "cases" repeating in a loop; you just have to put the last marker (3 = divisible by 3 and 5) as the first on the list (since 15 modulo 15 is 0).
char( "300102100120100", mod(n, 15) + 1) select "n-th modulo 15, plus 1" character from the "cycle string", do the test in when(), and print  with put.

Remarks:

If the Fizz, Buzz, and FizzBuzz phrases could be "replaced" by F, B, and X the code would be 13 bytes shorter, that's why I wrote 129 in brackets. :-)
The data; and run; are mandatory keywords of every SAS 4GL data step, so if you thinking only about the "working code" (and have in mind the previous remark) you could say 120 bytes, right? ;-) ;-)

Janet, 106 bytes
Note: Janet is not in TIO so I couldn't put a link or anything.
(loop[i :range[1 101]:let[f(zero?(% i 3))b(zero?(% i 5))]](print(cond(and f b)"FizzBuzz"f"Fizz"b"Buzz"i)))

Replace (zero? ...) with (= ... 0) to shave a few bytes.

Uhm... I tried that, but it didn't work. Lemme try it again, I didn't do it exactly the same way ur trying.

I tested my version on the online REPL at Janet for Mortals (I have never used Janet before but have used similar languages)

I will try tomorrow gtg now. I will comment by noon pst if it works. But thanks!

Frink, 131 bytes
This is still to be golfed, but because the docs are bare bones, it will be golfed through experimentation
for x=1 to 100
{
if x%15==0
{
println["FizzBuzz"]
} else
{
if x%3==0
{
println["Fizz"]
} else
{
if x%5==0
{
println["Buzz"]
} else
{
println[x]
}
}
}
}

By my reading of the linked page only the for loop's braces are necessary.

@Neil Then you'd need then which would increase the byte count

No, that's only if you want the controlled statement on the same line.

I might have misread so you might still need the braces on the outer else clauses too.

Scala, 90 bytes
for(i<-1 to 100)println{var s="";if(i%3==0)s="Fizz";if(i%5==0)s+="Buzz";if(s=="")i else s}

UniBasic, 106 bytes
FOR I=1 TO 100;D='';IF MOD(I,3)=0 THEN D='Fizz'
IF MOD(I,5)=0 THEN D:='Buzz'
IF D='' THEN D=I
CRT D;NEXT I

Windows Batch, 172
@setlocal enableDelayedExpansion&for /l %%N in (1 1 100) do @(set v=&set/a1/(%%N%%3^)||set v=Fizz&set/a1/(%%N%%5^)||set v=!v!Buzz&if defined v (echo !v!)else echo %%N)2>nul

JavaScript, 73 bytes
for(i=s='';i++<100;s+=((i%3?'':'Fizz')+(i%5?'':'Buzz')||i)+"\n");alert(s)

Hassium, 160 Bytes
Here's it in Hassium. Surprised there's never been a FizzBuzz challenge before. There's also some lengthier (but more interesting) FizzBuzz examples here
func main(){foreach(x in range(1,100)){if(x%15==0){println("fizzbuzz");}else if(x%3==0){println("fizz");}else if(x%5==0){println("buzz");}else println(x);}}

Run online and see expanded version here

@FryAmTheEggman Duly noted and added. Thanks.

The capitalization of Fizz and Buzz is wrong. 2. <1 is shorter than ==0. 3. All curly braces ({}) can be eliminated.

JavaScript, 73 71 65 bytes
for(i=1;i<101;i++)console.log((i%3?"":"Fizz")+(i%5?"":"Buzz")||i)

This was my first answer, what was the problem with the format?

Generally, language and size headers should be a header. Also, your current code doesn't seem to work, but you can fix it by replacing console.info with writeln (I tested it here and it worked.)

Do I need to specify the size or only the language? writeln is not valid in JavaScript, console.info is like console.log; both are valid.

Ah, OK, didn't realize that about writeln. You have to specify both the language and the size, on the same line. Also, I would reccommend using console.log if possible, that'll save you an extra byte.

Also, welcome to PPCG!

Thanks, Do you have a tool for calculating the size?

We usually use this.

Groovy, 71 bytes
(1..100).each{i->println i%15<1?'FizzBuzz':i%5<1?'Buzz':i%3<1?'Fizz':i}

Swift, 77 bytes
for i in 1...100{print(i%15<1 ?"FizzBuzz":i%3<1 ?"Fizz":i%5<1 ?"Buzz":"\(i)")}

@RichardG.Nielsen It's considered poor etiquette to edit some else's golfed code. Suggesting it in a comment is fine, or you could post your own answer since you came up with it independently.

Scala, 103 94 bytes
for{i<-1 to 100;s=(if(i%3==0)"Fizz"else"")+(if(i%5==0)"Buzz"else"")}println(if(s=="")i else s)

thx @Ben (shortened by 9 bytes)

You can save 9 bytes by using a for comprehension: for{i<-1 to 100;s=(if(i%3==0)"Fizz"else"")+(if(i%5==0)"Buzz"else"")}println(if(s=="")i else s)

STATA, 115 bytes
qui{
set ob 100
g a="Fizz" if!mod(_n,3)
g b="Buzz" if!mod(_n,5)
g c=a+b
replace c=string(_n) if c==""
}
l c,noo noh

qui{} suppresses output for everything in that block. First set the number of observations to be 100. Then generate variable a to be "Fizz" for every observation where its index number is divisible by 3. Then generate variable b to be "Buzz" for every observation where its index number is divisible by 5. Generate variable c to be the concatenation of these two. Then, replace c with the index number (STATA uses 1 indexing) if it is still an empty string. Then list the results of c in a table without observation numbers or headers.
Only works in the "real" STATA interpreter. I need to add functions and conditions to the online interpreter for it to work there.
A different solution in 116 bytes:
forv x=1/100{
if!mod(`x',3){
di"Fizz"_c
if!mod(`x',5) di"Buzz"_c
}
else if!mod(`x',5) di"Buzz"_c
else di `x' _c
di
}

This solution goes through a for loop and checks whether the loop variable is divisible by 3 or not. If it is, it prints "Fizz". Then it checks if it is divisible by 5 and prints "Buzz". Otherwise, it checks if it is divisible by 5 and prints "Buzz". If not, it prints the loop variable.

OCaml, 106
for i=1to 100do
let(!)n=i mod n<1and p=Printf.printf
in!3&p"Fizz"=();!5&p"Buzz"=()or!3||p"%d"i=();p"
"done

Apparently this isn't a very good attempt as the shortest one on anarchy golf is only 97.

Groovy, 83 80 bytes
(1..100).each{def f=it%3,b=it%5;println!f&&!b?'FizzBuzz':!f?'Fizz':!b?'Buzz':it}

Rust, 145 137 131 bytes
Golfed
fn main(){for i in 1..101{let s=i.to_string();println!("{}",match i%15{0=>"FizzBuzz",3|6|9|12=>"Fizz",5|10=>"Buzz",_=>&(s)[..]});}}

Ungolfed
fn main() {
    for i in 1..101 {
        let s = i.to_string();
        println!("{}", match i % 15 {
            0        => "FizzBuzz",
            3|6|9|12 => "Fizz",
            5|10     => "Buzz",
            _        => &(s)[..]
        });
    }
}

Uses the current stable version of Rust (1.5.0).

You can remove a semicolon after println! call, as println! returns (). Also, it's possible to replace &(s)[..] with &s.

Racket, 125 122 bytes
(for([x(range 1 101)])(define(m n)(=(modulo x n)0))(displayln(cond[(and(m 3)(m 5))'FizzBuzz][(m 3)'Fizz][(m 5)'Buzz][x])))

Simplest approach, took some work to get it lower than 130 bytes. Inspired by the Java example.
Pretty-printed code
(for ([x (range 1 101)])
  (define (m n)
    (= (modulo x n) 0))
  (displayln (cond
               [(and (m 3) (m 5)) 'FizzBuzz]
               [(m 3) 'Fizz]
               [(m 5) 'Buzz]
               [x])))

TCL, 208 bytes
Golfed:
set i 1;while {$i<101} {set p "";if {[expr $i % 3]==0} {set p [concat $p {fizz}]};if {[expr $i % 5]==0} {set p [concat $p {buzz}]};if {[expr $i % 3]>0&&[expr $i % 5]>0} {set p [concat $p $i]};puts $p;incr i;}

Ungolfed:
set i 1
while {$i<101} {
    set p ""
    if {[expr $i % 3]==0} {set p [concat $p {fizz}]}
    if {[expr $i % 5]==0} {set p [concat $p {buzz}]}
    if {[expr $i % 3]>0 && [expr $i % 5]>0} {set p [concat $p $i]}
    puts $p
    incr i
}

Python 2, 91
1;exec"print'FizzBuzz'if _%3==_%5==0else'Fizz'if _%3==0else'Buzz'if _%5==0else _;_+=1;"*100

Kotlin, 145 bytes
fun main(a:Array<String>){IntRange(1,100).forEach{val f=it%3==0;val b=it%5==0;var x="";if(f)x+="Fizz";if(b)x+="Buzz";if(!f&&!b)x+=it;println(x)}}

Try it online!

Kotlin, 119 115 bytes
fun main(a:Array<String>){for(i in 1..100)println(if(i%3<1)"Fizz" else ""+if(i%5<1)"Buzz" else if(i%3<1)"" else i)}

Try it Online!

Could you trim any more of the whitespace (e.g. in if(i % 5 < 1))?

:O I completely missed that there

You need whitespace between a keyword and a literal, so I think that is all the whitespace that can be trimmed now

Actually,it doesn't work for 15 and multiples: it only prints Fizz

Parenthesis around the first if/else can fix this in 117 bytes: fun main(a:Array){for(i in 1..100)println((if(i%3<1)"Fizz" else "")+if(i%5<1)"Buzz" else if(i%3<1)"" else i)}

Python 91 Bytes
for n in range(100):
    c=""
    if n%3==0:c+="fizz"
    if n%5==0:c+="buzz"
    if c=="":c=n
    print c

Elixir, 182 bytes
import Stream
f=fn(n)->(zip(cycle(["","","fizz"]),cycle(["","","","","buzz"]))|>zip(iterate(1,&(&1 + 1)))|>map(fn{{"",""},n}->n
{{p,o},_}->p<>o end))|>take(n)|>Enum.each(&IO.puts/1)end

LiveDemo
Calling: f.(100)

Ruby, 72 bytes
(1..100).each{|n|puts "#{n%3==0?'Fizz':''}#{n%5==0?'Buzz':n%3!=0?n:''}"}

Explanation
For each number from 1 to 100, print 'Fizz' if the number mod 3 is 0, then if the number mod 5 is 0, print 'Buzz' else if the number mod 3 is 0, print the number.

Hello, and welcome to PPCG! Great first post!

Groovy, 61 bytes
100.times{a=++it%3?"":"fizz"
a+=it%5?"":"buzz"
println a?:it}

Mathematica, 61 Bytes
Heavily inspired by this post on the mathematica stack exchange
fizzbuzz[#,,fizz,,buzz][[#~GCD~15~Mod~15]]&~Array~100//Column

This doesn't work properly for me on 10.2, but I assume that's a version variation as {#,,"fizz","fizzbuzz","buzz"}[[#~GCD~15~Mod~11]]&~Array~100//Column does

Plain Javascript (no console.log() & no alert()), 64 bytes
for(f=b='';f++<100;b+=(f%5?z||f:z+'Buzz')+'\n')z=f%3?'':'Fizz';b

Just copy/paste into any javascript console and hit enter.

REXX, 94 bytes
f.=
b.=
f.0='Fizz'
b.0='Buzz'
do i=1 to 100
  f=i//3
  b=i//5
  r=f.f||b.b
  if r<i then r=i
  say r
  end

Alternative 94 byte solution:
f='FizzBuzz'
do i=1 to 100
  r=left(f,(i//3=0)*4)right(f,(i//5=0)*4)
  if r='' then r=i
  say r
  end

Managed to get it down to 81. https://codegolf.stackexchange.com/questions/58615/1-2-fizz-4-buzz/120791#120791

Lua, 126 bytes
for i=1,100 do if i%15==0 then print"FizzBuzz"elseif i%3==0 then print"Fizz"elseif i%5==0 then print"Buzz"else print(i)end;end

I don't know Lua too well, but can you remove a few spaces (100do and 0then twice)

K, 52 Bytes
-1@{,/$$[#i:&~.q.mod[x;3 5];`Fizz`Buzz i;x]}'1+!100;

Thanks

Turtlèd, 221 bytes
99;,:[*,l]u[*d{*u,dr}ul' l[ l]ru]u3;[ [ r]l[ ' l]ll"Fizz";]<97:>5[ (*[ r]l[ ' l]ll)(zr)"Buzz";]<104:>[ lll'0rrr[ r]l{*' l{*l}{ l}(9'0l( r"1!")(9"10!"))(8'9)(7'8)(6'7)(5'6)(4'5)(3'4)(2'3)(1'2)(0'1)(!'0):{ l}}[ l]drrrr{zd}]

due to a bug (having two close curly brackets next to each other causes the second one to match to the first ones open bracket), the Try it online version is different for now (I put a space between the two close curly brackets)
99;,:[*,l]u[*d{*u,dr}ul' l[ l]ru]u3;[ [ r]l[ ' l]ll"Fizz";]<97:>5[ (*[ r]l[ ' l]ll)(zr)"Buzz";]<104:>[ lll'0rrr[ r]l{*' l{*l}{ l}(9'0l( r"1!")(9"10!"))(8'9)(7'8)(6'7)(5'6)(4'5)(3'4)(2'3)(1'2)(0'1)(!'0):{ l} }[ l]drrrr{zd}]

Try it online!
I might write an explanation if I get time motivated

Ruby, 68 65 bytes
q='Buzz';(1..100).map &->e{p e%3<1?'Fizz'+(e%5<1?q:''):e%5<1?q:e}

If you've made your program one byte shorter, you'll want to change the header to 64 bytes :)

Why map &->e{ and not map{|e| ?

braingasm, 40 bytes
The language is coming along nicely. A few recent features allows for a quite decent FizzBuzz, if I may say so myself:
100[>#3p["Fizz".+]#5p["Buzz".+]z[#:]10.]

Here's how it works:
100[               One hundred times:
    >                Go to the next cell.
    #3p[             If current cell number is divisble by 3:
        "Fizz".        Print "Fizz".
        +              Increment current cell
    ]
    #5p["Buzz".+]    Same thing for 5 and "Buzz".
    z[               If the current cell is 0 (hasn't been incremented):
      #:               Print current cell number
    ]
    10.              Print a newline
]

Hmm nice language... Is there an online interpreter or is it all offline?

@BetaDecay Thanks :) No, nothing online yet. I'm focusing mostly on implementing all my ideas, and to document things once they're a little bit more stable.

Python 2, 106 bytes
for n in range(1,101):
    a="Fizz"*int(n%3==0)+"Buzz"*int(n%5==0)
    if a=="": print n
    else: print a

Try it online!

What about this?

Python 2.7, 59 Bytes
for i in range(100):print i%3//2*'Fizz'+i%5//4*'Buzz'or i+1

Explanation:
for i in range(100)

This will  generate a list of numbers from 1 to 100 and assign it to the i variable.
print i%3//2*'Fizz'+i%5//4*'Buzz'or i+1

Note that this loop will repeat 100 times, and in each time, the loop will do what this line is commanding.

"This will generate a list of numbers from 1 to 100" I think you meant 0 to 99, otherwise you wouldn't need to use i+1 :)

You don't need //; with integer arguments, / performs integer division in Python 2. -~i saves an additional byte. https://tio.run/##K6gsycjPM/r/Py2/SCFTITNPoSgxLz1Vw9DAQNOqoCgzr0QhU9VY30hL3S2zqkpdO1PVVN9ES92pFMjJL9Kty/z/HwA

Recursiva, 46 bytes
EmB100"%a15:%a5:%a3:a!'Fizz'!'Buzz'!'FizzBuzz'

Try it online!
Explanation:
EmB100"%a15:%a5:%a3:a!'Fizz'!'Buzz'!'FizzBuzz'
E                                              - Stringify and join with new-lines
 m                                             - map with
  B100                                         - Range [1,2..100]
      "                                        - mapping function start
       %a15:%a5:%a3:a!'Fizz'!'Buzz'!'FizzBuzz' - string as per divisibility

%a15:%a5:%a3:a!'Fizz'!'Buzz'!'FizzBuzz' roughly translates to this if-else block:

if(a%15):
    elif(a%5):
        elif(a%3):
            return a
        else:
            return 'Fizz'
    else:
        return 'Buzz'
else:
     return 'FizzBuzz'

Extremely late answer and for a language that has already a bit too many answers, however, i've not seen a single function answer that actually RETURNS the expected string, instead of printing it to console, so here it is:
Javascript 73 bytes
(i=0,r="")=>i>99?r:f(++i,r+=(i%5?i%3?i:'Fizz':i%3?'Buzz':'FizzBuzz')+'
')

AsciiDots, 152 bytes
 #
/$""
\~\
 @\-\
[=]@*-\
/@----*-~&
|0/---*[>]
|@\<>$_"Buzz"@1)
|*-~/ /-/
||[%]-\>#100)
v\-*#5*/
|.//
| \<>$_"Fizz"@1)
|/-~/
@|[%]-\
0\-*#3/
*-[+]
\#1/

Try it online!

Funky, 59 bytes
for(i=1i<100i++)print((("Fizz"*1&!i%3)+("Buzz"*1&!i%5))ori)

Try it online!

nodejs repl, 60 bytes
for(i=0;++i<101;util.puts(i%5?s||i:s+'Buzz'))s=i%3?'':'Fizz'

With latest node, this prints a deprecation warning to the console.  This presumably violates the rule about printing to STDERR, but using an older version of node will fix this.

Answers are not required to be in the latest version of their language, so this is still valid.

APL Nars 93 chars
h;i;j
i←0
L:j←0⋄i+←1⋄→A×⍳0≠3∣i⋄⍞←'Fiz'⋄j←1
A:→B×⍳0≠5∣i⋄⍞←'Buz'⋄j←1
B:→C×⍳j=0⋄→D
C:⍞←i
D:⎕←''⋄→L×⍳i≤99

Indented:
 ∇ h;i;j
  i←0
L:j←0⋄i+←1⋄→A×⍳0≠3∣i⋄⍞←'Fiz'⋄j←1
A:         →B×⍳0≠5∣i⋄⍞←'Buz'⋄j←1
B:         →C×⍳j=0⋄→D
C:    ⍞←i
D:    ⎕←''⋄→L×⍳i≤99 ∇

APL(NARS), 44, 43, 39 chars 78 bytes
⊃{⍱/z←0=3 5∣⍵:⍕⍵⋄∊z/'fizz' 'buzz'}¨⍳100

In practice I follow Adam suggest.
I had seen other APL solutions, so I copied the way.
In the follow APL code, ←A here suppress the output of A.
←{⎕←∊{∨/j←0=3 5∣⍵:j/'fizz' 'buzz'⋄⍵}⍵}¨⍳100
{⎕←∊{∨/j←0=3 5∣⍵:j/'fizz' 'buzz'⋄⍵}⍵⋄⍬}¨⍳100
This above should return at end 100 void list, but it seems they are not showed at last here.
{⎕←{×+/j←0=3 5∣⍵:⊃,/j/'fiz' 'buz'⋄⍵}⍵⋄⍬}¨⍳100
This just above has one error because fiz and buz should be fizz and buzz
{⎕←{0<+/j←0=(3 5)∣⍵:⊃,/j/('fiz' 'buz')⋄⍵}⍵⋄⍬}¨⍳100
:for i:in⍳100⋄{0<+/j←0=(3 5)∣⍵:⊃,/j/('fiz' 'buz')⋄⍵}i⋄:endfor

Ever so slightly golfed (and adding the missing "z"s): ⊃{∨/j←0=3 5∣⍵:∊j/'fizz' 'buzz'⋄⍕⍵}¨⍳100

Clean, 148 + 2 = 150 bytes
+2 for the -b compiler flag
module m
import StdEnv
f[0,0,_]="FizzBuzz"
f[a,b,n]|a==0="Fizz"|b==0="Buzz"=fromInt n
Start=flatlines[fromString(f[n rem 3,n rem 5,n])\\n<-[1..100]]

Try it online!

C, 152 bytes
#include<stdio.h>
#define p printf
int i,f;main(){while(i++<100){if(i%3==0&&(f=1))p("Fizz");if(i%5==0&&(f=1))p("Buzz");if(f==0||(f=0))p("%d",i);p("\n");}}

Ungolfed one:
#include<stdio.h>
#define p printf
int i,f;
main()
{
    while(i++<100)
    {
        if(i%3==0&&(f=1))p("Fizz");
        if(i%5==0&&(f=1))p("Buzz");
        if(f==0||(f=0))p("%d",i);
        p("\n");
    }
}

This is not ok: main(){while(i++<100){(i%3<1&&p("fizz"))+(i%5<1&&p("buzz"))<1&&p("%d",i);p("\n");} ?

C (gcc), 101 bytes
#define P printf
main(i){for(i=0;i++<100;P("\n"))(i%3<1&&P("fizz"))+(i%5<1&&P("Buzz"))<1&&P("%u",i);}

It could have one indefinite behavior in the use + operation, the order of evaluation could be swapped.
Try it online!

You can change #define P printf to #define P printf( to cut off three bytes.

94 bytes

Kotlin, 115 bytes
fun main(a:Array<String>){(1..100).map{println(when(it%15){0->"FizzBuzz";3,6,9,12->"Fizz";5,10->"Buzz";else->it})}}

Try it online!

face, 152 bytes
(FizzBuzz%d@
)\F*,c'Fo>m+*1+m=*m?*m1+m3+m4+m5+11334455$BF"B4$%B"%4$N%"N3:~0?%=+3?=31?w=F4>:3%=+5?=51?w=B4>:5??+p="%c+w="=>:+w=N1>+++1*=55*==4+==1-=+=?=~

Annotated:
(FizzBuzz%d@
)
\F*,c'Fo>               ( obtain data pointer, a number, and stdout )
m+*1+                   ( counter variable, goes from 1 to 100 )
m=*m?*                  ( result and temp variables )
m1+m3+m4+m5+11334455    ( relevant constants )
$BF"B4$%B"%4$N%"N3      ( get pointers to Fizz, Buzz, %d, and \n )
:~
    0?                  ( has either Fizz or Buzz been printed? )
    %=+3?=3             ( skip to label 3 if not divisible by 3 )
    1?w=F4>:3           ( otherwise, print "Fizz" )
    %=+5?=51?w=B4>:5    ( same for "Buzz" )
    ??+p="%c+w="=>:+    ( if we didn't print anything, print the number )
    w=N1>               ( print a newline )
    +++1                ( increment the counter )
    *=55*==4+==1-=+=    ( set the result variable to 100-n )
?=~

Try it online! (The trailing newline is required on TIO due to a bug that's been fixed in a newer version of face.)

J, 73 Bytes
}.":`('Fizz'"_)`('Buzz'"_)`('FizzBuzz'"_)@.((0:=3&|)++:@(0:=5&|))"0 i.101

Definitely not the greatest, looking for ways to improve this.
Explanation:
                                                                 "0 i.101  | To each number from 0 to 100
                                           ((0:=3&|)++:@(0:=5&|))          | 1 if divisble by three, 2 if by 5, 3 if by both
                                         @.                                | Using the result of the previous verb, select a verb from the following gerund
  ":`('Fizz'"_)`('Buzz'"_)`('FizzBuzz'"_)                                  | Apply the appropriate Fizz-Buzz string
}.                                                                         | Remove the first entry (since we counted 0)

17, 229 bytes
17 was made after the challenge was made, but not designed to be any good at it. This code could probably be golfed a bit smaller, but it is a reasonably hard language to do anything with.
Golfed version(removed unneeded space and duplicated numbers where useful):
0{2 #
1 +
:
2 @
5g ==
1 +
0 @}1{2 # 3 % ! 3 *
2 # 5 % ! 5 *
+ 10 + 0 @}13{42 $ 63 $ 73 : $ $ a $
0 0 @}15{3f $ 6f $ 73 : $ $ a $
0 0 @}18{42 $ 63 $ 73 : : : $ $ 3f $ 6f $ $ $ a $
0 0 @}10{2 # $$ a $
0 0 @}}777{0 2 @
0 1 @
0 0 @}

Ungolfed version:
0 {
2 #
1 +
:
2 @
5g ==
1 +
0 @
}

1 {
2 # 3 % ! 3 *
2 # 5 % ! 5 *
+ 10 + 0 @
}

13 {
42 $ 63 $ 73 $ 73 $ a $
0 0 @
}

15 {
3f $ 6f $ 73 $ 73 $ a $
0 0 @
}

18 {
42 $ 63 $ 73 $ 73 $ 3f $ 6f $ 73 $ 73 $ a $
0 0 @
}

10 {
2 # $$ a $
0 0 @
}

777 {
0 2 @
0 1 @
0 0 @
}

Explanation:
Block 0:
Load value at 2, add 1, duplicate, store at 2, if value == 100 push 1, else 0, add 1, store at 0.
Block 1:
Will only be ran after block zero if value != 100. Load from 2, mod 3, not, times 3. If value at 2 is a multiple of 3 it will be 3, else 0. Same again for 5, add them and 17(looks like 10, but remember it uses base 17) and stores value at 0.
Block 13(or 20):
Will only be run after 1 if value is a multiple of 3, not 5. Push and print ascii values for Fizz\n
Block 15(or 22):
Will only be run after 1 if value is a multiple of 5, not 3. Push and print ascii values for Buzz\n
Block 18(or 25):
Will only be run after 1 if value is a multiple of 3 and 5. Push and print ascii values for FizzBuzz\n
Block 10(or 17):
Will only run after 1 if value is not multiple of 3 or 5. Prints numeric form of value.
Block 777(or 2149):
Like main for C++, first block to be run

kavod, 688 bytes
535 9}122 2}122 2}105 2}70 2}4 2}122 3}122 3}117 3}66 3}4 3}1 0><-+0>~0~><3 66 9}165.86?<1+>><-+2 0 86 9}478.><-+><5 100 9}165.120?<1+>><-+3 0 120 9}478.><-+<140?><-+><139 9}392.0><-+1+><10#100 158 9}258.162?47.9{.171 9}178.><-+9{.0 8}0 8}8}9}8{9{1+8{>8}9}8{9{>214 9}276.218?241.><-+<7}><<+8{1+8}8}7{196.><-+<1-+<-8{1-9{.-265 9}318.1 273 9}296.9{.-283 9}318.0 1-293 9}296.9{.-303 9}318.307?313.><-9{.1+9{.323?9{.><1+331?359.8}9}8{9{1-345?355.8}9}8{9{325.1+363.1-363.8}9}8{9{><-+9{.0 8}9}8{9{-9{.396?451.><0 406 9}276.457?><-+418 9}421.9{.425?445.10 433 9}178.439 9}421.48+#9{.~0~9{.48+#9{.><-+45#469 9}378.475 9}421.9{.8}~><8}489?499.1-8}>#8{485.><-+8{><8}513?526.1-<8}9}8{9{509.8{+8{~9{.

Try it online!
Formatted better:
535 9}122 2}122 2}105 2}70 2}4 2}122 3}122 3}117 3}66 3}4 3}1 0><-+0>~0~><3 66 9}165.86?<1+>>
<-+2 0 86 9}478.><-+><5 100 9}165.120?<1+>><-+3 0 120 9}478.><-+<140?><-+><139 9}392.0><-+1+>
<10#100 158 9}258.162?47.9{.171 9}178.><-+9{.0 8}0 8}8}9}8{9{1+8{>8}9}8{9{>214 9}276.218?241.
><-+<7}><<+8{1+8}8}7{196.><-+<1-+<-8{1-9{.-265 9}318.1 273 9}296.9{.-283 9}318.0 1-293 9}296.
9{.-303 9}318.307?313.><-9{.1+9{.323?9{.><1+331?359.8}9}8{9{1-345?355.8}9}8{9{325.1+363.1-363
.8}9}8{9{><-+9{.0 8}9}8{9{-9{.396?451.><0 406 9}276.457?><-+418 9}421.9{.425?445.10 433 9}178
.439 9}421.48+#9{.~0~9{.48+#9{.><-+45#469 9}378.475 9}421.9{.8}~><8}489?499.1-8}>#8{485.><-+8
{><8}513?526.1-<8}9}8{9{509.8{+8{~9{.

Ok so I can only really explain this vaguely, but stacks 2 and 3 hold the strings Fizz and Buzz. The program loops is roughly equivalent to the following code:
push 0 ;dummy

:fb
    drop
    copy 0
    dup
    call divides 3
    jif not3
        load
        add 1
        copy
        drop
        call puts 2 0

    :not3
    drop

    dup
    call divides 5
    jif not5
        load
        add 1
        copy
        drop
        call puts 3 0

    :not5
    drop

    load
    jif cont
        drop
        dup
        call putn
        push 0

    :cont
    drop
    add 1
    dup

    putc 10

    call gt 100
    jnt fb

ret

...just translated into pseudo-ops codes. Yeah. Then the rest of the program is defining sanity functions.
Guide to reading
J 9}N. usually means "call function at N, and return to J afterwards"; 9{. signifies this return.

Wumpus, 49 bytes
"zzuB"L)=S5%4*&;"zziF"L3%!!4*&;l=]&oL~!?ONL"d"-:.

Try it online!
Explanation
I haven't yet found a good way to write compact programs with branching control flow, so I decided to avoid branches altogether for this one (handling conditionals via skipping individual instructions). The program is a single line which is a run in a loop (because the . at the end skips back to the first character).
We'll be using the stack depth to determine whether Fizz and/or Buzz needs to be printed, so we can't keep the loop counter on the stack. Instead, we'll be using the default register for this (which is initialised to zero).
"zzuB"   Tentatively push the code points for "Buzz" onto the stack.
L)=S     Load the loop counter from the register, increment it, and store a
         copy back in the register.
         I'll call the loop counter for this iteration i.
5%       Compute i % 5 to test divisibility by 5.
4*       Multiply by 4. This gives 0 if 5 divides i, and some n ≥ 4 if it doesn't.
&;       Discard that many values from the stack. Discarding from an empty
         stack does nothing, so if 5 doesn't i, we get rid of "Buzz",
         otherwise, we do nothing.

         The code for "Fizz" is similar:
"zziF"   Push the code points for "Fizz".
L3%      Compute i % 3.
         This time, we can't just discard n ≥ 4 values, but we have to
         discard exactly 4 values, otherwise we might get rid of the "Buzz".
!!       Double logical NOT. Gives 0 for 0 and 1 for positive values.
4*       Multiply by 4. Now we've got 0 if 3 divides i and 4 otherwise.
&;       Discard that many values to get rid of "Fizz" if 3 doesn't divide i.
l        Push the stack depth D.
=]       Make a copy for later and shift it to the bottom of the stack.
&o       Print D characters from the top of the stack. If any of "Fizz" or
         "Buzz" were left on the stack, this prints them. Otherwise, D = 0
         and this does nothing.
L~       Load i and put it underneath D.
!?O      If D = 0, print i (in decimal). Otherwise, i remains on the stack.
N        Print a linefeed.
L"d"-    Compute i-100. This is zero when we want to end the program.
:        Compute i/(i-100). When we've reached i = 100, this terminates the
         program due to the attempted division by zero. Otherwise, this
         leaves some junk value X on the stack.
.        Jump to (0, X), emptying the stack. But since it's impossible to
         go out of bounds in Wumpus, the coordinates will automatically be
         taken modulo the grid dimensions. Since the grid is only one row
         tall, the y-coordinate becomes X%1 = 0, so regardless of X, this
         always jumps back to the beginning of the program.

Visual Basic .NET (Mono), 151 bytes
Module M
Sub Main
Dim i,s
For i=1To 100
s=""
s=IIf(i Mod 3,s,"Fizz")
s=IIf(i Mod 5,s,s+"Buzz")
Console.WriteLine(IIf(s="",i,s))
Next
End Sub
End Module

Try it online!

Yabasic, 108 bytes
Yet Another basic answer.
For i=1To 100
S$=""
If!Mod(i,3)Then S$="Fizz"Fi
If!Mod(i,5)Then S$=S$+"Buzz"Fi
If S$=""Then?i Else?S$Fi
Next

Try it online!

TIS, 573 + 48 = 621 bytes
Code (573 bytes):
@0
MOV ANY DOWN
MOV ANY RIGHT
@1
MOV ANY DOWN
ADD DOWN
MOV ANY DOWN
ADD DOWN
MOV ANY LEFT
MOV LEFT DOWN
ADD DOWN
@2
SUB 101
JLZ C
HCF
C:ADD 102
MOV ACC LEFT
@3
MOV ANY DOWN
MOV ANY UP
@4
MOV UP DOWN
MOV ANY UP
MOV UP DOWN
MOV ANY UP
MOV UP DOWN
MOV ANY UP
MOV UP DOWN
MOV ANY UP
MOV UP RIGHT
MOV ANY DOWN
MOV ANY UP
@5
MOV ANY DOWN
MOV ANY LEFT
@6
ADD UP
MOV 70 DOWN
MOV 105 DOWN
MOV 122 DOWN
MOV 122 DOWN
MOV 0 UP
@7
MOV UP ACC
JEZ N
MOV ACC DOWN
N:MOV -1 RIGHT
MOV 0 UP
@8
MOV ANY ACC
JLZ N
MOV 66 DOWN
MOV 117 DOWN
MOV 122 DOWN
MOV 122 DOWN
MOV 0 UP
JRO -7
N:MOV 10 DOWN

Layout (48 bytes):
3 3
CCCCCCCCC
O0 ASCII -
O1 NUMERIC -
O2 ASCII -

Try it online!
Explanation
I think my TIS emulator is ready for its debut! This is an emulator inspired by (and based on) the wonderful game TIS-100. However, where the game only emulates the 100 model of the TIS series, I have designed this emulator to reflect the full range of possibilities.
The code is in the format standardized by the game; we'll get to that in a bit. But first, the layout description just below that.
Layout
This is a specification for which model and configuration within the TIS range we desire. Whereas the model in the game (also called TIS-100) is only found in a 3 rows by 4 columns layout, for this solution I require something different.
I desire a 3 by 3 square instead. Since there are multiple types of nodes that can fall in each slot, I specify that all nine are Compute nodes (other types include e.g. stack memory).
In a TIS, the top row of nodes may read in input from above themselves (if so configured) and the bottom row may write below themselves to perform output (again, if so configured). For this challenge, no Inputs are needed, but I desire three different Outputs, corresponding to the three columns in this layout.
The first and third column outputs (O0 and O2) are each in ASCII mode; this means that they will translate the internal numeric type to an ASCII character when performing output. The center column (O1) is a NUMERIC output, meaning that the values sent to this output will instead be written out as a number. In all cases, we want the data to go to stdout (-).
Putting all this together gives the layout file seen above.
Code
TIS assembly code is stored in a flat file, as seen above. The code under the heading @0 will go in the first compute node, @1 in the second compute node, and so on. The layout in this solution looks like this:
0 1 2
3 4 5
6 7 8

Since each compute node only has capacity for 15 lines of code, my solution distributes the primary logic across 6 different nodes (the other three just bus data back and forth). Those 6 nodes are as follows:
Node @2, the top right, is the counter, counting 1 through 100, and terminating execution (HCF) upon reaching 101.
Node @1, the top center, sends every third number left (for Fizz), and all numbers down.
Node @6, the bottom left, produces "Fuzz" when given any number.
Node @4, the true center, sends every fifth number right (for Buzz), and all numbers down.
Node @8, the bottom right, produces "Buzz" when given a non-negative number and "\n" otherwise.
Node @7, the bottom center, produces a number if that number hasn't already been Fizzed or Buzzed (or both), and then requests a newline to be printed.
It is quite possible that this is not yet a fully optimal golf, but this is also the first golf I've done for TIS.

Hmm, I'm thinking that due to the decisions here, especially point 2, I could argue for not including the layout in the byte count. It is a 'different implementation', essentially. Opinions appreciated.

Jstx, 36 bytes
₧&0←+☺:@♥>ø↕₧K2→+◙♣>ø↕₧O2→+◙%↓2◙∟416

Explanation
₧& # Push literal 100
0  # Enter an iteration block over the first stack value and push the iteration element register at the beginning of each loop.
←  # Push literal false
+  # Store the first stack value in the a register.
☺  # Push literal 1
:  # Push the sum of the second and first stack values.
@  # Push three copies of the first stack value.
♥  # Push literal 3
>  # Push the modulus of the second and first stack values.
ø  # Push literal 0
↕  # Enter a conditional block if the top two stack values are equal.
₧K # Push literal Fizz
2  # Print the first stack value.
→  # Push literal true
+  # Store the first stack value in the a register.
◙  # End a conditional block.
♣  # Push literal 5
>  # Push the modulus of the second and first stack values.
ø  # Push literal 0
↕  # Enter a conditional block if the top two stack values are equal.
₧O # Push literal Buzz
2  # Print the first stack value.
→  # Push literal true
+  # Store the first stack value in the a register.
◙  # End a conditional block.
%  # Push the value contained in the a register.
↓  # Enter a conditional block if first stack value exactly equals false.
2  # Print the first stack value.
◙  # End a conditional block.
∟  # Push literal null
4  # Print the first stack value, then a newline.
1  # End an iteration block.
6  # Ends program execution.

Try it online!

Phooey, 57 bytes
&1[101>&0<@@%3{"Fizz">&1<}&%5{"Buzz">&1<}&>{<$i>}$c10<+1]

Try it online!
Explanation
&1                    set current cell to 1
[101                  until that cell is 101:
  >&0<                zero the cell to the right
  @@                  push two copies of the current cell to the stack
  %3{"Fizz">&1<}      if it's divisible by 3, print "Fizz"
  &%5{"Buzz">&1<}     if it's divisible by 5, print "Buzz"
  &                   restore cell
  >{<$i>}             if it's not, print the restored cell
  $c10                print a newline
  <+1                 increment the current cell
]

This actually doesn't look like such a bad language

@ASCII-only Thank you!

There's only one problem: this is nothing like Foo :P

@ASCII-only This is strikingly like foo, actually. The only thing in this answer unlike foo are the new while loops [...]

_> actually... have I spent my entire life thinking the meme language Foo/how it's represented in the meme post was actually all Foo did

@ASCII-only  So did I, which is one reason I made this language: to emphasize just how cool Foo was.

ORACLE SQL (107 bytes)
select nvl(decode(mod(rownum,3),0,'Fizz')||decode(mod(rownum,5),0,'Buzz'),rownum)from xmltable('1 to 100')

DEMO

Pyret, 150 bytes
d={(a,b):if num-modulo(a,b) == 0:if b == 3:"Fizz"else:"Buzz" end else:""end}
each({(y):q=d(y,3) + d(y,5)
print(if q == "":y else:q end)},range(1,101))

You can try this online by copying it into the online Pyret editor!
Pyret is a language designed with education in mind, so there's a couple things it enforces to keep things readable in normal programs. This explains why some of the operators are surrounded by spaces and the presence of newlines in the program.
The {(...): ...} syntax is shorthand for lambda expressions, which gives us the following ungolfed version:
d = lam(a,b):
  if num-modulo(a,b) == 0:
    if b == 3:
      "Fizz"
    else:
      "Buzz"
    end
  else:
    ""
  end
end

each(
  lam(y):
    q = d(y,3) + d(y,5)
    print(
      if q == "":
        y
      else:
        q
      end)
  end,
  range(1,101))

Python 2.7, 105 bytes
for i in range(1,101):
 w=''
 if i%3==0:w+='Fizz'
 if i%5==0:w+='Buzz'
 if w!='':print w
 else:print i

I know this can be golfed a lot. But I don't know how  though.

General golf tip that is surprisingly pythonic: w!='' can be w.

Though for a more golfed version of the straight-forward approach, see this answer.

Lua, 80 bytes
Can probably be improved:
s=("").sub for i=1,100 do r=s("Fizz",i%3*5)..s("Buzz",i%5*5)print(r..s(i,#r))end

Readable version:
s=("").sub
for i=1,100 do
  r=s("Fizz",i%3*5)..s("Buzz",i%5*5)
  print(r..s(i,#r))
end

Python 3, 62 bytes
for _ in range(1,101):print("Fizz"*(_%3<1)+"Buzz"*(_%5<1)or _)
Try it online!

Pyth, 39 bytes
VS100J+?q0%N3"Fizz"k?q0%N5"Buzz"k?qJkNJ

Try it online!
There's probably an easier and shorter way. Also is(polishNotation, annoying).
This is roughly equivalent to:
for x in range(1,100):
a = "" + "Fizz" if x%3==0 else "" + "Buzz" if x%5==0 else ""
print(a if a!="" else x)

Dart, 80 bytes
f({i=0}){for(;i++<100;)print((i%3>0?'':'Fizz')+(i%5>0?(i%3>0?'$i':''):'Buzz'));}

f({i=0}){for(;i++<100;)print("${i%3>0?'':'Fizz'}${i%5>0?(i%3>0?i:''):'Buzz'}");}

f({i=0}){for(;i++<100;)print(i%15<1?'FizzBuzz':i%5<1?'Buzz':i%3<1?'Fizz':'$i');}

Try it online!

Alchemist, 101 bytes
0x+f+b->Out__+x+b
0x+0f->Out_"Fizz"+2f+x
0x+0b+f->Out_"Buzz"+5b+x
x+0b->f
x+b+a->_+Out_"\n"!99a+2f+4b

Try it online!
Takes a few confusing shortcuts in order to reuse the Buzz for FizzBuzzs.
Explanation:
!99a+2f+4b           # Initialise the program with
                         # 99a (overall counter)
                         # 2f (Fizz counter)
                         # 4b (Buzz counter)
                         # 1_ (num counter)

0x+f+b->Out__+x+b        # If there's a Fizz and Buzz counter, print the current number
                         # Also decrement the Fizz counter
0x+0f->Out_"Fizz"+2f+x   # If there's no Fizz counter, print Fizz
                         # And reset the Fizz counter
0x+0b+f->Out_"Buzz"+5b+x # If there's no Buzz counter and there is a Fizz counter, print Buzz
                         # Reset the Buzz counter
                         # And decrement the Fizz counter

# After we've printed any of these, set the x flag
x+0b->f                  # If there is also no Buzz counter, go back to the Buzz printer
                         # This is to ensure the Buzz check comes after the Fizz check
x+b+a->_+Out_"\n"        # Otherwise, decrement the total counter
                         # Decrement the Buzz counter
                         # Increment the num counter
                         # And print a newline

JavaScript (Node.js), 71 bytes
for(i=0;++i<101;)console.log((l=i%3<1?"Fizz":'')+(i%5<1?"Buzz":l?"":i))

Try it online!

JavaScript, 127 122 81 79 bytes
for(e=0;++e<101;)console.log(e%3||e%5?e%3==0?"Fizz":e%5==0?"Buzz":e:"FizzBuzz")

Another way, based on Taylor Scott's solution, is only 78 72 bytes
for(e=0;++e<101;)s=e%3?"":"Fizz",s+=e%5?"":"Buzz",console.log(""==s?e:s)

Try it online! - First Solution
Try it online! - Second Solution

Thanks @JoKing I'm still getting back into OOP from procedural (college class)

Thanks @taylor-scott

Stuff in the format a==0?b:c can be a?c:b

C++ 123 122 bytes
-1 thanks to JonathanFrech
#import<iostream>
#define s std::cout<<
main(){for(int i;100-i++;s(i%3?"":"Fizz")<<(i%5?"":"Buzz")<<'\n')i%3*i%5?s i:s"";}

You can move the declaration of i inside the loop. Furthermore, is this variables initial value guaranteed to be zero?

@JonathanFrech I read somewhere that global ints are automatically initialized to 0

Racket, 107 Bytes
(for{[x 100]}(define(f a b n)(if(=(modulo(+ 1 x)n)0)a b))(printf"~a~a\n"(f'Fizz""3)(f'Buzz(f""(+ 1 x)3)5)))

Try it online!
The inspiration for my answer comes from Luca H's post.
All I did afterwards was factor out the repetitive calls to (if (modulo ...) ...). Sadly, there are two copies of (+ 1 x) left that I couldn't factor out using less characters, so they remain.
Ungolfed (including removing f):
(for {[x 100]}
  (printf "~a~a\n"
          (if (= (modulo (+ x 1) 3) 0) 'Fizz "")
          (if (= (modulo (+ x 1) 5) 0) 'Buzz
              (if (= (modulo (+ x 1) 3) 0) "" (+ x 1)))))

33, 60 bytes
1asz'Fizz'{tlot}t[3rznpn1cztsl5rz"Buzz"npn1tlaz''nqtl1aztsi]

Explanation:
1asz          (Initialise the counter with 1)
'Fizz'{tlot}t (Create function 'Fizz' to print current number)
[             (Start of loop)
3rz           (Check if divisible by 3)
np            (If so, print 'Fizz')
n1czts        (Store result for later)
l             (Load the counter back)
5rz           (Check if divisible by 5)
"Buzz"np      (If so, print 'Buzz')
n1tlaz        (Check if divisible by neither by retrieving the value from earlier)
''nqt         (If neither 'Fizz' nor 'Buzz' was printed, print the number)
l1azts        (Restore our counter and increment it)
i]            (Print a newline and repeat from the start of the loop)

Julia, 87 Bytes
for i in 1:100;println(i%3<1 ? "Fizz"*(i%5<1 ? "Buzz" : "") : (i%5<1 ? "Buzz" : i));end

More readable:
for i in 1:100
    if i%3 < 1
        print("Fizz")
        if i%5 < 1
            println("Buzz")
        else
            println()
        end
    elseif i%5 < 1
        println("Buzz")
    else
        println(i)
    end
end

Not sure if there's already a Julia submission here. Also my first time golfing c:
Indirect thanks to @Najkin because I saw their reply to a C# submission saying that you can use <1 instead of ==0 and that helped me save 3 bytes over my previous 90-byte solution!
BTW if you see any "unnecessary" spaces, they're actually necessary as Julia would throw a syntax error without them. (Why?!)

oh I just realized there's a 72-byte Julia submission lol

Visual Basic Script, 123 bytes
For i=1To 100
S=""
If i Mod 3=0Then
S="Fizz"
End If
If i Mod 5=0Then
S=S+"Buzz"
End If
If S=""Then
S=i
End If
MsgBox S
Next

Sorry @Taylor Scott but I basically copied your MY-BASIC solution

Hoon, 115 bytes
This is a Hoon say generator which can be used to write the output to a file from the dojo.
turn is Hoon's map, it takes a list from 1..100 generated via (gulf 1 100) and uses string interpolation and the 'null check' conditional rune ?~ to generate either "Fizz", "Buzz" or "FizzBuzz" according to the value of x. This is paired with the value of x as a string <x> and then - and + are used to select the fizzbuzz string if not empty, otherwise the number string from the pair.
:-
%say
|=
*
:-
%txt
%+
turn
(gulf 1 100)
|=
x=@
=>
"{?~((mod x 3) "Fizz" ~)}{?~((mod x 5) "Buzz" ~)}"^<x>
?~
-
+
-

Wren, 78 bytes
It turns out that this is pretty hard to golf.
for(i in 1..100)System.print(i%15==0?"FizzBuzz":i%5==0?"Buzz":i%3==0?"Fizz":i)

Try it online!

Scala, 65 64 Bytes
1.to(100).map(n=>{print(s"\n$n"+(if(n%3==0)"fizz")+(if(n%5==0)"buzz"))})

I've just started golfing so any tips are appreciated (yes I have read this)

Not exactly. You have to output n only for those which are neither “fizz” or “buzz”.

@manatwork Okay good to know will fix

Symja, 140 134 128 bytes
For(i=1,i<101,i++,If(Mod(i,5)==0,s=s<>"Fizz");If(Mod(i,3)==0,s=s<>"Buzz");If(Mod(i,5)*Mod(i,3)!=0,s=s<>ToString(i));s=s<>"\n");s

Y'all can try it online here
Just a standard fizzbuzz approach. This is tweetable BTW, so there's that too.

123 bytes (not sure how to save a link in that Symja compiler). What is golfed: both ==0 are <1; the !=0 is >0 and the For(i=1,i<101,i++, is For(i=0,++i<101,. PS: You may want to add a s=""; in your linked version, since I received an error because s was overflowing at first.

Erlang (escript), 166 bytes
i(A,B,C,D)->if A==B->C;1<2->D end.
f(X)->i(X rem 3,0,"Fizz","")++i(X rem 5,0,"Buzz","").
z(0)->"";z(X)->z(X-1)++"~n"++i(f(X),"",integer_to_list(X),f(X)).
z()->z(100).

Try it online!

05AB1E, 37 bytes
т>GN3ÖUi"Fizz"?}N5ÖVi”ÒÖ”?}XY~_iN?}¶?

Try it online!
т>GN3ÖUi"Fizz"?}N5ÖVi”ÒÖ”?}XY~_iN?}¶?  # full program
  G                                    # for N in [1, 2, ...,
т                                      # ..., 99...
 >                                     # plus 1]...
       i                               # if...
   N                                   # variable...
     Ö                                 # is divisible by...
    3                                  # literal...
              ?                        # then output without trailing newline...
        "Fizz"                         # literal
               }                       # end if
                    i                  # if...
                N                      # variable...
                  Ö                    # is divisible by...
                 5                     # literal...
                         ?             # then output without trailing newline...
                     ”ÒÖ”              # "Buzz"
                          }            # end if
                               i       # if...
      U            V       XY          # N is...
                              _        # not...
      U            V       XY          # divisible by...
                             ~         # either...
      U                    X           # 3...
                             ~         # or...
                   V        Y          # 5...
                                 ?     # then output without trailing newline...
                                N      # variable
                                  }    # end if
                                    ?  # output without trailing newline...
                                   ¶   # newline
                                       # implicit end loop

Alternatively, you can replace ¶? with õ,: Try it online!
                                    ,  # output with trailing newline...
                                   õ   # empty string

FALSE, 86 bytes
[\100*\/$100$@\/*-0=]m:1[$100>~][0\$3m;![\%1\"Fizz"]?$5m;![\%1\"Buzz"]?\0=[$.]?10,1+]#

Try it online!
Explanation
[\100*\/$100$@\/*-0=]m: Define Modulo Function
    [\100*\/ Divide number * 100 by the divisor to get decimals
    $100$@/* Get truncated result
    -0= Subtract to get decimal, if equal to 0, then the modulo is zero and return true. If not, return false as we don't care about the result
1 Put counter on stack
[$100>~] Check if number is greater than 100
[0\$3m;![\%1\"Fizz"]?$5m;![\%1\"Buzz"]?\0=[$.]?10,1+]# Do FizzBuzz if not
    [0\ Number to see if both % 3 and % 5 failed
    $3m;! Number % 3
    [\%1\"Fizz"]? If yes, do what is in brackets
        [\%1\ Set number to 1
        "Fizz"]? Print Fizz
    $5m;! Number % 5
    [\%1\"Buzz"]? If yes, do what is in brackets
        [\%1\ Set number to 1
        "Buzz"]? Print Buzz
    \0= Check if both modulo functions failed
    [$.]? If yes, do what is in brackets
        [$ Duplicate our counter so it doesn't get destroyed
        .]? Print the counter
    10, Print ASCII character 10 (line break)
    1+]# Increment counter

Could most likely be way better.

Canvas, 31 bytes
Ａ２＾｛ｗ３％０≡Fizz×ｙ５％０≡Buzz×＋：？Ｏ］ｙＯ

Try it here!
Okay seriously guys why is it that both ascii-art focused languages didn't already have a FizzBuzz? This uses my favourite FizzBuzz approach found in the Vyxal answer.

Javascript, 99 bytes
This isn't a good, or small solution, but it works:
for(let i=1;i<101;i++){console.log((i%3==0&&i%5==0)?"FizzBuzz":(i%3==0)?"Fizz":(i%5==0)?"Buzz":i);}

Explanation:
for (let i=1;i<101;i++) // Loop through, until reaching 100
{
    console.log(
    (i%3==0 // If I is a multiple of 3
    &&      // And
    i%5==0  // If I is a multiple of 5
    )?"FizzBuzz": // Print "FizzBuzzz"
    (i%3==0)?"Fizz":  // If I isn't either of those, check whether I is a multiple of 3, if so, print "Fizz"
    (i%5==0)?"Buzz" // If I isn't a multiple of 3, check whether I is a multiple of 5, if so, print "Buzz"
    :i // Else, just print i
    );
}

Mouse-83/Mouse-2002, 73 bytes
1F:(F.Z4*1+<^0A:F.3\0=["Fizz"1A:]F.5\0=["Buzz"A.1+A:]A.0=[F.!]"!"F.1+F:)$

Try it online!
Yet another fizzbuzz. Polyglots both versions listed and beats the current answer. The funny thing is that I came up with this independently of the other answer and managed to use the same approach.

Phooey, 53 4847 bytes
[100+1@@@@%3{"Fizz">&<}&%5{"Buzz">&<}>{&$i}"
"]

Try it online!
Outgolfed the creator at his own language.

[100            while cell is not 100
   +1             increment cell
   @@@@           push four copies to the stack
   %3             set cell to cell mod 3
   {              if cell is not zero
     "Fizz"            print fizz
     >&<               pop value into the next cell to mark it
   }              endif
   &              pop original value from stack
   %5{"Buzz">&<}  repeat for buzz
   >              move to the next cell
   {              if neither fizz or buzz set the next cell
     &                 Pop to the cell
     $i                print number
   }              endif
   "\n"         print newline
                  all paths popped the value to this cell, loop
]               end

The stack and tape are all filled with a lot of junk (as in ~200 numbers on the stack 100 items on the tape) and at the end since I don't consistently move the pointer or pop the same amount of times, but I don't care.
I may make fun of the interpreter, but it is a pretty nice language.

-5 bytes: Use stack instead of tape, and don't restore the tape and stack
-1 byte: Simplify the logic to avoid the extra pop (in exchange for double the stack usage ).

Myddin, 157 bytes
use std
var p=std.put
const main={
for var i=1;i<101;i++
match(i%3,i%5)
|(0,0):p("FizzBuzz\n")
|(0,_):p("Fizz\n")
|(_,0):p("Buzz\n")
|(_,_):p("{}\n",i)
;;;;}

BRASCA, 81 bytes
1b1[x0aB:b3%0=[x`zziF`oooo1a0]xB:b5%0=[x`zzuB`oooo0A1+a]xA0=[xB:bn0]xB1+:bH1+<lo]

Try it online!
There'll be an explanation coming soon. The tio link is the interpreter split over the header and footer in such a way that the program can be entered into the code box.

ThumbGolf, 49 bytes
Machine code (little endian pairs):
2100 3101 0008 dec0 d003 b908 a303 de03
004a de6a b922 a305 de03 e003 6946 7a7a
b100 de21 de3a 2964 d1eb 4770 7542 7a7a
00

Commented assembly:
        // Include the ThumbGolf wrapper macros
        .include "thumbgolf.inc"
        .globl main
        .thumb_func
main:
        // Start the counter with zero and increment first.
        // It aligns better than incrementing at the bottom.
        movs    r1, #0
.Lloop:
        adds    r1, #1
.Lthree:
        // r0 = r1 % 3
        movs    r0, r1
        umodi   r0, 3   // udf #0300; .short 0xd003
        // if r0 == 0
        cbnz    r0, .Lten
        // if so print "Fizz"
        adr     r3, .Lfizz
        puts    r3      // udf #0003
.Lten:
        // do the same for Buzz
        // r2 = (r1 * 2) % 10, a.k.a. r1 % 5
        // we do this because umod.10 is a special narrow instruction :)
        lsls    r2, r1, #1
        umod.10 r2      // udf #0152
        cbnz    r2, .Lnum
        adr     r3, .Lbuzz
        puts    r3      // udf #0003
        // jump to the newline
        b       .Lnoprint

        // Normally, "Fizz" and "Buzz" are 5 byte strings due to the null
        // terminator, which SUCKS. This is because Thumb instructions MUST
        // be 2 byte aligned, and pool loads that are not 4 byte aligned are
        // annoying wide instructions.
        //
        // However, I have a trick up my sleeve.
        //
        // CBZ is encoded as so:
        //    |15 14 13 12|11|10| 9| 8| 7  6  5  4  3 |2  1  0|
        //    | 1  0  1  1| 0| 0| i| 1|      imm5     |  Rn   |
        // Let's focus on bits 0-7, which, since ARM is little endian, appear
        // first.
        //
        // imm5 is the offset in opcodes relative to 4 bytes after the current
        // instruction (a.k.a. where the PC is for dumb reasons). Technically,
        // there is a 6th bit in bit 9, but that is only for larger offsets.
        //
        // .Lnoprint is exactly 4 bytes after the instruction, so the offset
        // is zero:
        //   0 0 0 0 0 r r r
        // Now, for the register argument, if we set it to r0...
        //   0 0 0 0 0 0 0 0
        // Behold. A free null terminator.
        //
        // This is great, as it not only lets us cheat a byte in Fizz, but also,
        // it makes everything align perfectly so we don't need any wide adr
        // instructions. We can just put Buzz at the bottom of the file and it
        // will be 4 byte aligned as well.
.Lfizz:
        .ascii  "Fizz"  // null terminated by cbz encoding
.Lnum:
        // was r1 % 3 not zero (meaning did we not print Fizz?)
        cbz     r0, .Lnoprint
        // if so, print r1 as an integer
        puti    r1      // udf #0041
.Lnoprint:
        // putspc is a narrow instruction that prints one of 8 special characters,
        // one of which includes \n.
        putspc  '\n'    // udf #0072
        // loop while r1 != 100
        // replace with a register for variable length
        cmp     r1, #100
        bne     .Lloop
        // return
        bx      lr
.Lbuzz:
        .asciz  "Buzz"

My second submission in my brand new WIP ThumbGolf language, an ISA extension to Thumb-2.
It shows off both the new I/O instructions and the modulo instructions (with the special narrow encoding for 10).
That little hack by null terminating with cbz saves a lot, and it was really fun to figure out.
As mentioned in my cat program, this can be run on ARM Linux or QEMU by linking the ThumbGolf runtime. I don't have an online interpreter yet (and I doubt I could afford hosting one lul)

Actually, you should have based it on x86 machine code... So is ThumbGolf a RISC or a CISC?

ThumbGolf is what I envision to be a "RISC golfing language". I am sticking to this limitation, even if it isn't gonna win any contests.

As I personally find golfing languages that let you answer a complex challenge in one byte ruin the whole point of golfing. ♂

///, 235 bytes
/(/\/\///%/111()/\\\\(p/1\/(x/%%%1(t/xxxxxxxxxx(>p^=)=^!)=$)vvt&@
^^!)=^=)=^^$v)v^|^^v)v1^v)av^^v)av^v)v^>(^/\(/>(>t/%&/&%(1&/1(%11@/@%11(1@/1(&p&(@p@(&/Fizz(@/Buzz(|p001(|(/0x/1\0(0p_1(0_/_(1p2(22/4(42/6(44/8(2p3(4p5(6p7(8p9(_(/=\=(==

Try it online!
There is already a /// answer, but it is pretty boring. I thought I would try to make a more algorithmic one, even though it is a little longer ;)
Ungolfed:
Try it online!

JavaScript: 76 bytes
for(i=1;i<101;i++)console.log(i%3<1?'fizz'+(i%5<1?'buzz':''):i%5<1?'buzz':i)

Not the best solution we have, but not the worst either...
The "nested" ternary operator adds either buzz or nothing to the fizz part depending on the results of the divisibility test.

Excel, 82 79 Bytes
=LET(x,ROW(1:100),a,IF(MOD(x,3),"","Fizz")&IF(MOD(x,5),"","Buzz"),IF(a="",x,a))

This wasn't valid when the question was asked.
Spreadsheet

M4, 115 bytes
Also TIL that ifelse can have more than four arguments.
define(f,`ifelse($1,101,,`ifelse(eval($1%15),0,fizzbuzz,eval($1%5),0,buzz,eval($1%3),0,fizz,$1)
f(incr($1))')')f(1)

Try it online!

M4, 143 bytes, SUSv2-compatible.
define(f,`ifelse(`$1',101,,`g(`$1',ifelse(eval($1%3),0,fizz)`'ifelse(eval($1%5),0,buzz))
f(incr($1))')')define(g,`ifelse(len($2),0,$1,$2)')f(1)

Try it online!
I am not familiar with M4, but I tried some bests. What quotations can be removed?
With comments
dnl def f(n): return "" if n==101 else g(n,("fizz" if n%3==0 else "")+("buzz" if n%5==0 else "")+"\n"+f(n+1))
define(f,`ifelse(`$1',101,`',`g(`$1',ifelse(eval($1%3),0,fizz)`'ifelse(eval($1%5),0,buzz))
f(incr($1))')')dnl
dnl def g(n,s): return n if len(s)==0 else n
define(g,`ifelse(len($2),0,$1,$2)')dnl
f(1)

Pxem, Filename: 96 81 bytes + Content: 0 bytes = 96 81 bytes.
Thanks, Neil, for providing a workaround for -15 bytes!

Filename (some are escaped): \020.z.t.m\005.%\001.yXXbuzz.a.m\003.%\001.yXXfizz.a.c.c.z.m\017.-.nXX@.a.c@.z.pXX.a.s\n.o.m\001.+.ct.a
Content: empty.

Try it online! (with pxem.posixism)
With comments
XX.z
.a\020.zXX.z # push 16; while :; do
  .a.tXX.z # heap = pop!
  .a.m\005.%\001.yXXbuzz.aXX.z # while 1>heap%5; do push "buzz"; break; done
  .a.m\003.%\001.yXXfizz.aXX.z # while 1>heap%3; do push "fizz"; break; done
  .a.c.c.z.m\017.-.nXX@.aXX.z # if empty?; then print(heap-15); push "@"; fi
    # this is how while empty?; do something; done works:
    # ".c.c.z bla bla bla .a"
    # NOTE: Fail on pxemi dot 7z and RPxem
    # They need some patches before installing
    # Implementation needs to be document-compliant
    # PS. RPxem v0.0.7 fixed dotC
  .a.c@.z.pXX.aXX.z # if top!="@"; then print pop all!; fi
  .a.sXX.z # pop!
  .a\n.oXX.z # print "\n"
  .a.m\001.+XX.z # push heap; add one to it
.a.ct.aXX.z # break if equal to 116
.a

Note

In Pxem, unlike other stack-based languages, subtraction and division does NOT rely on positions of two items; .- does push(abs(pop-pop)), .$ and .% stand for x=pop; y=pop; push(int(x>y?x/y:y/x)) and x=pop; y=pop; push(int(x>y?x%y:y%x)) respectively. Thus, when you try to do something like 13/17 or 13%17, you need to check which are greater first.
To avoid the specification, the program loops from 16 to 115.

Old version
1

To work around that division, could you not loop from 16 to 116, but subtract 15 before printing?

CSASM v2.1.2.1, 325 bytes
func main:
push 1
pop $a
.lbl a
clf.o
push $a
push 15
rem
push 0
comp
push $f.o
brtrue e
push $a
push 3
rem
push 0
comp
push $f.o
brtrue b
push $a
push 5
rem
push 0
comp
push $f.o
brtrue d
push $a
print.n
br c
.lbl b
push "Fizz"
print.n
br c
.lbl d
push "Buzz"
print.n
br c
.lbl e
push "FizzBuzz"
print.n
.lbl c
clf.o
inc $a
push $a
push 101
comp
push $f.o
brfalse a
ret
end

Commented and Ungolfed:
func main:
    ; Initilize the counter in the accumulator
    push 1
    pop $a

    .lbl loop
        ; Reset the Comparison flag
        clf.o

        ; $a % 15 == 0
        push $a
        push 15
        rem
        push 0
        comp

        ; Jump to label "printFizzBuzz" if the Comparison flag is true
        push $f.o
        brtrue printFizzBuzz

        ; $a % 3 == 0
        push $a
        push 3
        rem
        push 0
        comp

        ; Jump to label "printFizz" if the Comparison flag is true
        push $f.o
        brtrue printFizz

        ; $a % 5 == 0
        push $a
        push 5
        rem
        push 0
        comp

        ; Jump to label "printBuzz" if the Comparison flag is true
        push $f.o
        brtrue printBuzz

        ; None of the above were true.  Just print the number itself
        push $a
        print.n
        br checkCounter

    .lbl printFizz
        ; Print "Fizz"
        push "Fizz"
        print.n
        br checkCounter

    .lbl printBuzz
        ; Print "Buzz"
        push "Buzz"
        print.n
        br checkCounter

    .lbl printFizzBuzz
        ; Print "FizzBuzz"
        push "FizzBuzz"
        print.n

    .lbl checkCounter
        ; Clear the Comparison flag
        clf.o

        inc $a

        ; $a == 101
        push $a
        push 101
        comp
        push $f.o

        ; Keep looping until the above is false
        brfalse loop
    ret
end
```

Stax, 21 bytes
åS╬╕▌≡º$)ö;▀├Xè¶XΔ£≈♀

Run and debug it
Not sure why recursive's solution from the tutorial hasn't been posted here yet. Probably the most minimal fizzbuzz possible in stax.

Pinecone, 90 bytes
i:1|i<101|i:i+1@(i%3+i%5=0?print:"FizzBuzz"|i%3=0?print:"Fizz"|i%5=0?print:"Buzz"|print:i)

BRASCA, 58 bytes
1Hr,[0a:3%0=[a0`zziF`[o]]x:5%0=[a0`zzuB`[o]]A$=[x:n0]xxlo]

Try it online!

Knight, 50 48 43 bytes
;=n 0W>101=n+1nO|+*"Fizz"!%n 3*"Buzz"!%n 5n

Try it online!
-2 bytes: use string multiplication instead of IF
-5 bytes: I completely overlooked |, I assumed it had C semantics.
Ungolfed:
# start with n at 0
; = n 0
# increment n and loop while less than 101
: WHILE > 101 (= n + 1 n)
    # outlined from the output for clarity
    # concatenate:
    ; = fizzbuzz +
        # Fizz if n % 3 == 0
        : * "Fizz" ! (% n 3)
        # Buzz if n % 5 == 0
        : * "Buzz" ! (% n 5)
    # If fizzbuzz is not empty, output it, otherwise output n
    : OUTPUT | fizzbuzz n

C++20, 202 bytes
this is uncompetitive, but this was so fun I couldn't help but post it here.
#include <bits/stdc++.h>
using namespace std;auto f=[](int i){return i%15?(i%5?(i%3?to_string(i):"Fizz"):"Buzz"):"FizzBuzz";};int main(){for(auto i:views::iota(1,100)|views::transform(f))cout<<i<<endl;}

you have an extra space in 1, 100

@hyper-neutrino oh darn thanks

PostScript, 73 bytes
Using binary encoding:
000000 31 88 01 88 64 7b 2f 69 92 3e 92 33 28 46 69 7a
000010 7a 42 75 7a 7a 29 69 88 0f 28 42 75 7a 7a 29 69
000020 20 35 28 46 69 7a 7a 29 69 88 03 33 7b 92 6a 30
000030 92 3d 7b 2f 69 92 3e 92 33 7d 7b 92 75 7d 92 55
000040 7d 92 83 69 20 3d 7d 92 48

Try it online! (thanks to tail spark rabbit ear, ignore TIO's character count).
This is a straight-forward encoding of the following 101 byte program (in binary encoding, 136 n is a signed 8-bit integer and 146 n is command n from the system name encoding list in appendix F of the PostScript language reference).
1 1 100{/i exch def(FizzBuzz)i 15(Buzz)i 5(Fizz)i 3 3{mod 0 eq{/i exch def}{pop}ifelse}repeat i =}for

Try it online!
The non-binary encoded version can be reduced to 98 bytes if we don't mind leaving /i on the stack.
/i 1 1 100{def(FizzBuzz)i 15(Buzz)i 5(Fizz)i 3 3{mod 0 eq{/i exch def}{pop}ifelse}repeat i =/i}for

Try it online!

I made you a TIO thing of the binary.

@tailsparkrabbitear: Thanks for that. I hadn't even considered that the TIO bash would include Ghostscript. Perhaps put a note on the Postscript Code Golf tips page.

jq, 98 82 bytes
range(1;101)|if.%15<1then"FizzBuzz"elif.%3<1then"Fizz"elif.%5<1then"Buzz"else. end

Try it online!
Yet to golf it!
Removed superfluous spaces thanks to @DLosc.

Some simple golfs get you down to 82 bytes

Thanks @DLosc, I didn't realize you could remove the spaces!

Rockstar, 138 135 133 bytes
F takes I&S
let M be N/I
turn up M
if N-I*M
S's""

return S

N's0
while N-100
let N be+1
say F taking 3,"Fizz"+F taking 5,"Buzz" or N

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

Pure Bash,  70 bytes 69 bytes 68 bytes 63 + 1 = 64 bytes
The following program must be saved as x, which is for 1 byte of penalty.
''
((++x%3))||Fizz
((x%5))||$_\Buzz
echo ${_:-$x}
((x>99))||. x

Try it online!

OBTW I am outputting garbages to stderr, which may be against the rules.

outgolfed

RickRoll-Lang, 185 bytes
takemetourheart
give a up [*range(1,101)[::-1]]
togetherforeverandnevertopart
give i up a.pop()
give s up "Fizz"*(i%3<1)+"Buzz"*(i%5<1)
ijustwannatelluhowimfeeling [str(i),s][s>""]+"\n"

Explanation:
RickRoll-Lang keywords do not need spaces between them
takemetourheart                                   -- main() function declaration
give a up [*range(1,101)[::-1]]                   -- set a to reverse of int range [1, 101)
togetherforeverandnevertopart                     -- infinite loop
give i up a.pop()                                 -- pop last element of a and store in i
give s up "Fizz"*(i%3<1)+"Buzz"*(i%5<1)           -- string multiplcation to form fizzbuzz depending on modulus remainders
ijustwannatelluhowimfeeling [str(i),s][s>""]+"\n" -- print i if s is empty else s and a newline
                                                  -- implicit "say goodbye" (end block) at the end
                                                  -- another say goodbye

Try it online!

jq, 78 bytes
range(1;101)|. as $n|[(select(.%3==0)|"Fizz"),(select(.%5==0)|"Buzz")]|add//$n

Kotlin, 117 bytes
{for(i in 1..100){println("${if(i%3<1)"fizz" else ""}${if(i%5<1)"buzz" else ""}${if(!(i%3<1||i%5<1))"$i" else ""}")}}

Try it online!
as usual as it gets
edit: i hope the extra \n at the end is not a problem

JavaScript (code.golf), 62 56 bytes
for(i=0;++i<101;print(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'

This is a code.golf version, which allows usage of print instead console.log.
Here is the un-code.golfed version:
for(i=0;++i<101;console.log(i%5?f||i:f+'Buzz'))f=i%3?'':'Fizz'

SQLite, 183 bytes
WITH F AS(SELECT 1 AS N UNION ALL SELECT N+1 FROM F WHERE N<100)SELECT CASE WHEN N%15=0 THEN'FizzBuzz'WHEN N%5=0 THEN'Buzz'WHEN N%3=0 THEN'Fizz'ELSE CAST(N AS VARCHAR)END AS F FROM F;

Try it online!
Ungolfed code:
WITH F AS(
  SELECT
    1 AS N
  UNION ALL
  SELECT
    N + 1
  FROM
    F
  WHERE
    N < 100
)
SELECT
  CASE WHEN N % 15 = 0 THEN 'FizzBuzz' WHEN N % 5 = 0 THEN 'Buzz' WHEN N % 3 = 0 THEN 'Fizz' ELSE CAST(N AS VARCHAR) END AS F
FROM
  F;

Squirrel, 131 bytes
for(local i=0;i++<100;)if(i%15==0)print("FizzBuzz\n")else if(i%5==0)print("Buzz\n")else if(i%3==0)print("Fizz\n")else print(i+"\n")

Try it online!
This is the original code that I created:
function fizzBuzz(n) {
  for (local i = 1; i <= n; i += 1) {
    if (i % 15 == 0)
      print ("FizzBuzz\n")
    else if (i % 5 == 0)
      print ("Buzz\n")
    else if (i % 3 == 0)
      print ("Fizz\n")
    else {
      print (i + "\n")
    }
  }
}

fizzBuzz(100);

Boo, 114 bytes
for i in range(1,101):
 if i%15==0:print'FizzBuzz'
 elif i%5==0:print'Buzz'
 elif i%3==0:print'Fizz'
 else:print i

Try it online!

GFortran, 138 bytes
character(8)s;do i=1,100;s=''
if(mod(i,3)<1)s='fizz';if(mod(i,5)<1)s=trim(s)//'buzz'
if(s>'')print'(A)',s;if(s<'A')print'(i0)',i;enddo;end

Try it Online!
  145 bytes
Could save bytes using print*, but the output is untidy

Pascal, 162 B
See also Free Pascal.
This program, however, requires a processor supporting features of ISO standard 10206 “Extended Pascal”, specifically the :0 width specifier in conjunction with string/char values.
Usually, for numeric arguments the n in write(42:n) specifies a minimum width the decimal representation shall occupy.
With string values, however, it specifies the exact width, i. e. possibly zero.
program p(output);var i:1..100;begin for i:=1 to 100 do if 0 in[i mod 3,i mod 5]then writeLn('Fizz':4*ord(i mod 3=0),'Buzz':4*ord(i mod 5=0))else writeLn(i:1)end.

For sake of readability the ungolfed version of above code plus some explanatory comments:
program fizzBuzz(output);
    var
        i: integer;
    begin
        { Remember, in Pascal `for`-loop limits are inclusive. }
        for i := 1 to 100 do
        begin
            { Create a `set of integer` and check membership of `0`: }
            if 0 in [i mod 3, i mod 5] then
            begin
                writeLn('Fizz':4 * ord(i mod 3 = 0), 'Buzz':4 * ord(i mod 5 = 0))
            end
            else
            begin
                { For numeric values `:0` would have the same effect as `:1`. }
                { Therefore this is in the `else` branch. }
                writeLn(i:1)
                { The `:1` just ensures there are no leading blanks }
                { regardless of implementation (the compiler) used. }
            end
        end
    end.

For a non-golfed version visit, for example, RosettaCode.

Assembly (MIPS, SPIM), 202 bytes
main:add$7 1
li$2 4
la$4 F
rem$6 $7 3
bnez$6 n
syscall
n:rem$5 $7 5
bnez$5 o
or$4 5
syscall
j e
o:beqz$6 e
abs$4 $7
li$2 1
syscall
e:li$2 11
li$4 10
syscall
bne$7'd'main
j$ra
.data
F:.asciiz"Fizz""Buzz"

Try it online!
Explanation
This does a lot of SPIM abuse
This assumes the following features of an empty program:

$a3/$7 is 0
.data is otherwise empty and therefore page-aligned (address of F is 0x10010000)

# initial SPIM state:
#   $a0 ($4): argc
#   $a1 ($5): argv
#   $a2 ($6): envp
#   $a3 ($7): 0
main:
    add     $a3, 1         # Increment accumultor (initially 0)
    li      $v0, 4         # v0 = PRINT STRING
    la      $a1, FizzBuzz  # a1 = "Fizz\0Buzz\0"
test_fizz:
    rem     $a2, $a3, 3    # a2 = acc % 3
    bnez    $a2, test_buzz # skip if not multiple of 3
fizz:
    syscall                # print("Fizz")
test_buzz:
    rem     $a1, $a3, 5    # a3 = acc % 5
    bnez    $a1, test_num  # skip if not multiple of 5
buzz:
    or      $a0, 5         # FizzBuzz is aligned, FizzBuzz | 5 == FizzBuzz + 5
    syscall                # print("Buzz")
    j       newline        # print newline
test_num:
    beqz    $a2, newline   # skip if acc % 3 == 0
num:
    abs     $a0, $a3       # abs is shorter than move for positive nums
    li      $v0, 1         # v0 = PRINT NUMBER
    syscall                # print(acc)
newline:
    li      $v0, 11        # v0 = PRINT CHARACTER
    li      $a0, '\n'      # a0 = '\n'
    syscall                # print('\n')
    bne     $a3, 100, main # Loop if not 100 (I use 'd' to avoid a space)
    j       $ra            # return

    .data
FizzBuzz:
    .asciiz "Fizz"         # 0x10010000 = "Fizz\0"
    .asciiz "Buzz"         # 0x10010005 = "Buzz\0"

Whitespace(v0.3 on ideone.com), 210 bytes
code visualized with replacing space,tab,newline to 's','t','n':
sssnnsssnssstntssssnsssststtstsstnsstttnnstnssstttstttststnssttstnnstntssnntstnsnstnstnsstnssststsnsnssnstnsstssntsstnttsnnnnnssnstssttnsnttsttnttssnsnssssttsssstntstttnsstnsssssttttstsnsnstnsstnsssssnnssssnntn

Show result on ideone
Notice: This code works fine on ideone.com, though, has a wrong result on tio.com because of a difference in behavior of "putc" with a large number ( > 255 ).
Show wrong result on tio.com
Without the rule "Nothing can be printed to STDERR", this code can be shortened to 207 bytes with omitting an "end"(nnn) instruction.
Here is the disassembled code ( created with my original tool ).
push +0(0b)   # 0000: ss-s-n
mark +0(0b)   # 0004: nss-s-n
push +1(1b)   # 0009: ss-st-n
add           # 0014: tsss
dup           # 0018: sns
push +361(9b)  # 0021: ss-ststtstsst-n
push -3(2b)   # 0034: ss-ttt-n
call null     # 0040: nst--n
push +1909(11b)  # 0044: ss-stttstttstst-n
push -5(3b)   # 0059: ss-ttst-n
call null     # 0066: nst--n
mul           # 0070: tssn
jzero -0(0b)  # 0074: nts-t-n
dup           # 0079: sns
puti          # 0082: tnst
mark -0(0b)   # 0086: nss-t-n
push +10(4b)  # 0091: ss-ststs-n
dup           # 0099: sns
dup           # 0102: sns
putc          # 0105: tnss
mul           # 0109: tssn
sub           # 0113: tsst
jneg +0(0b)   # 0117: ntt-s-n
end           # 0122: nnn
mark null     # 0125: nss--n
copy +3(2b)   # 0129: sts-stt-n
swap          # 0136: snt
mod           # 0139: tstt
jneg +0(1b)   # 0143: ntt-ss-n
dup           # 0149: sns
push +97(7b)  # 0152: ss-sttsssst-n
mod           # 0163: tstt
putc          # 0167: tnss
putc          # 0171: tnss
push +122(7b)  # 0175: ss-sttttsts-n
dup           # 0186: sns
putc          # 0189: tnss
putc          # 0193: tnss
push +0(0b)   # 0197: ss-s-n
mark +0(1b)   # 0201: nss-ss-n
ret           # 0207: ntn

Klong [klongpy], 62 bytes
,/{Z:::[x!3;"";"Fizz"],:[x!5;"";"Buzz"];:[Z;Z;$x],:#10}'1+!100

A nifty little K-like language I found on reddit. Uses the klongpy interpreter rather than the official C Klong interpreter.
Explained
,/{...}'1+!100
       '       :" To each item (x) in...
        1+!100 :" the range [0, 100) + 1 -> [1, 100]...
  {...}        :" map the function described in the next code block
,/             :" join into a single string

Z:::[x!3;"";"Fizz"],:[x!5;"";"Buzz"];:[Z;Z;$x],:#10
Z::                                                   :" Define Z to be:
                   ,                                  :" The concatenation of:
   :[x!3;"";"Fizz"]                                   :" "Fizz" if x % 3 == 0, else "" (note that the condition isn't actually x % 3 == 0 - it'd need to be something like 0=x!3. The order of the truthy and falsey branches has been swapped to accomodate this)
                    :[x!5;"";"Buzz"]                  :" and "Buzz" if x % 5 == 0, else "" (same note applies as above)
                                    ;:[Z;Z;$x]        :" if Z isn't empty, return whatever Z is, else str(x)
                                              ,:#10   :" And add a newline (chr(10)) to that

Thunno H N, \$ 27 \log_{256}(96) \approx \$ 22.22 bytes
e1+D35d%0="FBiuzzzz"Zlz*Js~

Attempt This Online!
Thunno H d, \$32 \log_{256}(96) \approx\$ 26.34 bytes
R{1+zt3%!"Fizz"*s5%!"Buzz"*+s~ZK

Attempt This Online!
Explanations:
           # The H flag implicitly pushes 100 to the stack
e1+        # Map over range(100) and add one each time:
   D       #   Duplicate the number
    35d    #   Push the digits of 35 - [3, 5]
       %0= #   Push [divisible by 3, divisible by 5]
"FBiuzzzz" #   Push string "FBiuzzzz"
Zl         #   Uninterleave to get ["Fizz", "Buzz"]
  z*J      #   Multiply element-wise and join
     s~    #   Swap and logical or with the number
           # After the map, the N flag joins by newlines

           # The H flag implicitly pushes 100 to the stack
R{         # Loop through range(100):
  1+       #   Add one
    zt     #   Triplicate so it is on the stack three times
      3%!  #   Is it divisible by 3?
"Fizz"*    #   Multiply this by the string "Fizz"
           #   i.e. push "Fizz" if it's divisible by 3, "" otherwise
       s   #   Swap so the number is back on top
5%!        #   Is it divisble by 5?
   "Buzz"* #   Multiply this by the string "Buzz"
           #   i.e. push "Buzz" if it's divisible by 5, "" otherwise
+          #   Add them togther, so we have "Fizz", "Buzz", "FizzBuzz", or ""
 s~        #   Swap and perform `or`, so we get the number if it's ""
   ZK      #   Print with a newline
           # After the loop, the d flag stops the implicit output

Pyt, 91 bytes
11`ŕĐĐ5%⇹3%?ŕ:ŕ8⬡2+ƇĐ2ᴇ5+Ƈ7⬠Ƈ5Ș;?ŕ:ŕ8⬡2+ƇĐ9⬠Ƈ6⬡Ƈ4Ș;ǰĐĐąɬɔĐƩ?ŕ⇹ą⇹*ǰ⇹ąɬą\ǰƖ⇹ƥ:ŕŕŕƖĐƥ;⁺Đ2ᴇ⁺<łĉ

Try it online!

Code
Action

1
Pushes 1

1`ŕ...ł
Do... while top of stack is truthy

ĐĐ5%⇹3%
Gets n mod 5 and n mod 3

?ŕ:ŕ8⬡2+ƇĐ2ᴇ5+Ƈ7⬠Ƈ5Ș;
If n mod 3 is 0, push "Fizz"

?ŕ:ŕ8⬡2+ƇĐ9⬠Ƈ6⬡Ƈ4Ș;
If n mod 5 is 0, push "Buzz"

ǰĐĐąɬɔĐƩ?ŕ⇹ą⇹*ǰ⇹ąɬą\ǰƖ⇹ƥ:ŕŕŕƖĐƥ;
If the stack contains any letters, print only the letters; otherwise, print the number

⁺Đ2ᴇ⁺<
Is the number less than 100?

ĉ
Clears the stack

Aubergine, 225 bytes ( 222 bytes with error )
:Ba=aA-A1=ba-b1:BA-Ai+Ai+a1=bi=oA+a1:bA+a1+iA=a1-ii?		\0B*Fizz\0\0FBuzz\0[-aa=aA-aA+ai-ai=bi-bi+iA=ab-a1=oA=oB=bi-bi+B1+b1=oB+b1-aa:aB+ii=a1=aA+A1+A1-aa=aA-a1-a1=bA-a1-bA=Ab-ib-a1-AA-a1-AA-aa-a1-A1-a1=bA-a1-Ab-a1+A1-a1-iAo01

* four \0 mean NUL(ASCII 0) character
Try it online!
The equivalent pseudo code in C is like below;

#include <stdio.h>
#include <stdint.h>

#define I(x) ((intptr_t)&&x)
#define P(x) *(void*)(x)

static void nop(void) {}

int main(void) {
  intptr_t
    *cp,*cpt,t,p,
    pvars0[] =
      { I(Tj3)-I(Tj1), I(Tj2)-I(Tj1), I(Tj2)-I(Tj1), 0, I(Tc1)-I(Tj3),
        I(Lb), 3, 'F', 'i', 'z', 'z', 0, I(Lb)-I(Tx2), },
    pvars1[] =
      { I(Lj), 5, 'B', 'u', 'z', 'z', 0, I(Lc)-I(Tx2), },
    dvars[] = { I(Tc2)-I(Tj3), '0', '1', '\n', 10, },
    *pbase[] = { &pvars0[6], &pvars1[1] },
    *dbase3=&dvars[2], *dbase1=&dvars[4];
  int i=0;

Lx: // Fizz/Buzz print ( i=0 for Fizz, i=1 for Buzz )
  // decrement counter
  cp = pbase[i];
  *cp-=1;
  if ( *cp!=0 ) goto P(*(cp-1));  // skip printing and jump to Lb/Jj
  *cp+=3; // restore the counter to 3 ( add more 2 for Buzz in Lc )
  cp+=1;
  p=I(Tx1);
Tx1: // putchar loop
  putchar(*cp);
  cp+=1;
  if ( *cp!=0 ) goto P(p); // jump to Tx1
  goto P(I(Tx2)+*(cp+1)); // jump to Lb/Lc
Tx2:

Lb: // Buzz print
  i=1;
  goto Lx;

Lj: // number print and post process
  cp=pbase[0];
  // select &pvars[0] thru &pvars[2] as jump offset
  cp-=*cp;
  cp-=3;
  cpt=dbase3;
  goto P( I(Tj1)+*cp ); // jump to Tj3(when Fizz) or Tj1/Tj2
Tj1: // print the upper digit
  cp=cpt-1;
  putchar(*cp);
Tj2: // print the lower digit
  putchar(*cpt);
Tj3: // print a new line and increment the lower digit
  cp=dbase3;
  *cp+=1;
  cp+=1;
  putchar(*cp);
  cp+=1;
  i=0;
  if ( *cp!=0 ) goto Lx; // next iteration
  return 0; // exit

Lc: // after Buzz
  // add more 2 to the Buzz counter
  cp=pbase[1];
  *cp+=2;
  // switch pvars0[3] ( jump offset ) between 0 and pvars0[4]
  cp=pbase[0]-2;
  t=*cp;
  cp-=1;
  t-=*cp;
  *cp=t;
  goto P( I(Tc1)-t ); // jump to Tc1/Tj3
Tc1: // carry up
  // reset jump offsets in pvars[1],pvars[2]
  // so that the 1st "goto" in Lj jump to Tj1 instead of Tj2
  cp-=1;
  *cp=0;
  cp-=1;
  *cp=0;
  // decrement global loop counter
  cp=dbase1;
  *cp-=1;
  // decrease the lower digit by 10
  cp-=1;
  t=*cp;
  cp-=1;
  *cp-=t;
  // increment the upper digit
  cp-=1;
  *cp+=1;
  cp-=1;
  goto P(I(Tc2)-*cp); // jump to Tj3
Tc2:
  nop(); // not reached
}

Each code block handles;

Label Lx
Print Fizz ( when i=0 ) or Buzz ( when i=1 ) if n is the multiple of 3 or 5.
Label Lb
Just jump to Lx after setting i=1.
Label Lj
Print n itself ( when Fizz or Buzz are not printed ) and do post-process.
Label Lc
Carry-up operation.

In Aubergine code, each address range corresponds to;

0 thru 2
The 1st instruction :Ba has no effect, but stores pbase[].
pbase[0] is ord(':')=58, pbase[1] is ord('B')=66.
3 thru 50
The code block with label Lx.
Lx: =aA-A1=ba-b1:BA-Ai+Ai+a1=bi=oA+a1:bA+a1+iA, Tx1: =a1-ii
* set i=0 ( -ii ) to implement goto Lx
51
A blank area.
52 thru 72
Stores pvars0[] and pvars1[]
73 thru 135
The code block with Label Lj.
Lj: -aa=aA-aA+ai-ai=bi-bi+iA, Tj1: =ab-a1=oA, Tj2: =oB, TJ3: =bi-bi+B1+b1=oB+b1-aa:aB+ii
The last instruction +ii jumps to an address out of range to stop the program.
136 thru 219
The code block with Label Lc.
Lc: =a1=aA+A1+A1-aa=aA-a1-a1=bA-a1-bA=Ab-ib, Tc1: -a1-AA-a1-AA-aa-a1-A1-a1=bA-a1-Ab-a1+A1-a1-iA
220 thru 224
Stores dvars[]
This area is accessed via minus addresses such as dbase1=-1 or dbase3=-3.

The 222 bytes version, which is shown below, outputs some error.
:Ba=aA-A1=ba-b1:BA-Ai+Ai+a1=bi=oA+a1:bA+a1+iA=a1-ii?		\0Q*Fizz\0\0\x9aBuzz\0=a1=aA+A1+A1-aa=aA-a1-a1=bA-a1-bA=Ab+ib-a1-AA-a1-AA-aa-a1-A1-a1=bA-a1-Ab-a1+A1-a1+iA-aa=aA-aA+ai-ai=bi-bi+iA=ab-a1=oA=oB=bi-bi+B1+b1=oB+b1-aa:aB$01

* \0 is NUL, and \x9a is a byte 232
This code cannot be run on TIO because TIO requires codes to be UTF-8 clean. ( a single \x9a is not valid as UTF-8 byte sequence )
The differences between 225B version and this 222B version are;

Exchange the position in code of the Lj code block and the Lc code block.
Replace relative backward jump instructions -ib, -iA in Lc code block to forward jumps +ib, +iA.
Omit the instruction +ii, which works to stop the code, from Lj code block.
* The code stops in error when the instruction pointer points the dvars area just after the Lj code block.

sclin, 63 bytes
100I-a \; tap
"Fizz""Buzz", over3 5, % ! ** c>< dup \pop |# n>o

Try it on scline!
My collection grows once again

TypeScript's type system, 183 bytes
//@ts-ignore
type G<I=[1],M=1,S="",N=I["length"],L=`${M extends 0?"Fizz":""}${`${N}`extends`${any}${0|5}`?"Buzz":""}`>=N extends 101?S:G<[...I,1],[1,2,0][M],`${S}${L extends""?N:L}
`>

Try it at the TS Playground
Finally sub 200, and by a longshot! I used an almost entirely different method to save 36 bytes.
Instead of having two types, one to check divisibility and one to construct the FizzBuzz output, I reduced it to just a single type.
This new solution checks divisibility by 3 by cycling a type argument M between 1, 2, and 0, and outputting "Fizz" when M extends 0. It checks divisibility by 5 by checking if the decimal representation of the loop counter ends in 0 or 5 (`${N}`extends`${any}${0|5}`).
Below is my older solution, which is itself a newer version of one of my first TypeScript types golfs.

TypeScript’s Type System, 227 219 bytes
//@ts-ignore
type M<N,B,T>=N extends[...B,...infer R]?M<R,B,T>:N extends[]?T:"";type F<N=[1],S="",O=`${M<N,[1,1,1],"Fizz">}${M<N,[1,1,1,1,1],"Buzz">}`,Z=N["length"]>=Z extends 101?S:F<[...N,1],`${S}${O extends""?Z:O}
`>

Try it at the TS Playground
I already have an answer in TypeScript types here, but it’s from when I first started using TS, and is bad on multiple fronts:

It runs with compilation errors
It uses an external library
It doesn’t use tail-recursion, so it hits the recursion depth very fast and therefore requires lots of extra code
It’s long

This submission has none of the same problems, and uses a technique I’ve been sitting on for a while and haven’t had a chance to use until now.
Explanation:
// M does divisibility (unary numbers)
type M<
  N, // N is the dividend
  B, // B is the divisor
  T, // T is returned if N is divisible
>=
  // if B fits in N, let R be the difference
  N extends[...B,...infer R]
    ?M<R,B,T>    // recurse with N = R
    :N extends[] // else if N is 0
    ?T           // return T
    :""          // else return ""

// F generates the main FizzBuzz text
type F<
  N=[1], // N is the current number (in unary)
  S="",  // S is the whole string
  O=     // O is the text for the current iteration
    `${ // Fizz if N divisible by 3
      M<N,[1,1,1],"Fizz">
    }${ // concatenated to Buzz if N divisible by 5
      M<N,[1,1,1,1,1],"Buzz">
    }`,
  Z=N["length"] // Z is an alias for N in decimal
>=
  Z extends 101 // if N is 101,
    ?S          // return S
    :F<         // else recurse with
      [...N,1], // N + 1
      `${S}${   // append to S:
        O extends""?Z:O // Z if O is empty, else O
      }\n`      // append a newline
    >

Easyfuck, 103 92 90 bytes

Æ¡ãÄ©␟[Vîê§VTSx(\ùòîO␗.SÉD§ÏAPC>|¥ãÄSTSHYÞHù␋åoPU2c[HOPD®␊y$|NELóçÉ␞c[HOPD§Ü␔ò|úÛÇHTJÝÝCCHñsÄSTMWÞ»␂4-=}d␂␄␘\¢PAD

due to lack of unicode representations for c1 control characters, they have been replaced by their superscripted abbreviations
Decompressed:
c(<<%$>[+;]*<)p(.>>.r<..)r(J>>>>>)<<$r[^$>!>+>$c-`(Jp)r$>!>>>$<c-`(J>p)r>>[<<';]J<.<$r+^]@FBiuzd␁␁␃␅e␊

Explanation part 1:
c(<<%$>[+;]*<)p(.>>.r<..)r(J>>>>>)<<$r
c(           )                         define function c
  <<                                   go to the cell 2 steps to the left
    %$>                                modulo the cell by the value in storage, copy it to storage, move 1 cell to the right
       [  ]                            while loop
        +; *<                          increment the cell, break out of the while, multiply it by the value in storage, and move 1 cell to the left
              p(        )              define function p
                .>>.r<..               print ascii, move 2 cells to the right, print ascii, invoke function r, move 1 cell to the left, print ascii twice
                         r(      )     define function r
                           J>>>>>      go to the first cell and move 5 cells to the right
                                  <<$r move to the 2nd to last cell, copy it to storage and invoke function r

Explanation part 2:
[^$>!>+>$c-`(Jp)r$>!>>>$<c-`(J>p)r>>[<<';]J<.<$r+^]@FBiuzd␁␁␃␅e␊
[                                                 ]              while loop
 ^                                                               bitwise xor the cell with the storage cell
  $>!>+>                                                         copy the cell to storage, move 1 cell right, set the cell to value in storage, move 1 cell right, increment, move 1 cell right
        $c-                                                      copy the cell to storage, invoke function c, decrement
           `(Jp)                                                 if previous command caused an overflow, execute a lambda which moves the pointer to the first cell and invokes function p
                r$>!>>>                                          invoke function r, copy the cell to storage, move 1 cell to the right, set the cell to value in storage, then move 3 cells right
                       $<c-                                      copy the cell to storage, move 1 cell left, invoke function c, decrement
                           `(J>p)                                if previous command caused an overflow, execute a lambda which moves the pointer to the second cell and invokes function p
                                 r>>                             invoke function r and move 2 cells to the right
                                    [    ]                       while loop
                                     <<';                        move 2 cells left, print integer in the cell at the pointer, break out of the while
                                          J<.<$                  move to the last cell, print ascii, move 1 cell left, copy it to storage
                                               r+^               invoke function r, increment the cell at the pointer and xor it with storage cell
                                                   @             terminate program
                                                    FBiuzd␁␁␃␅e␊ initializer data

Python 2, 72 bytes
for x in range(100):print('Fizz'*(x%3>1)+'Buzz'*(x%5>3)or str(x+1))+'\n'

Not as clever as feersum's solution, but it avoids casting exec magic.
EDIT: with just two more parentheses, it works in Python 3 AND Python 2:
for x in range(100):print(('Fizz'*(x%3>1)+'Buzz'*(x%5>3)or str(x+1))+'\n')

even simpler, supress +'\n' and some parenbthesis : for x in range(100):print('Fizz'(x%3>1)+'Buzz'(x%5>3)or x+1)  so 63 bytes Pthon 3

APL, 56 50 bytes
⊣{1+⍵⊣⎕←∊2↑((0=3 5|⍵)/'Fizz' 'Buzz'),''(⍕⍵)}⍣100⊢1

Note: The very first ⊣ should suppress output in GNU APL. Replace it with → to get correct results in Dyalog, etc, or with portable assignment to some variable X← adding one byte.
A+, 51 bytes
(x←100)do↓⊃2↑((0=3 5|1+x)/4⊂'FizzBuzz'),⌽2↑<1↓⍕1+x;

These seem quite different, so why not put them in different answers?

While I wouldn't call A+ a “trivial variant,” it's a direct derivative of APL and I think any solution in one would translate to similar byte count in another. Also, I just updated it making the answers work exactly the same way.

The APL solution goes to 101 instead of stopping at 100.

ShapeScript, 57 bytes
0'1+0?3%1<"Fizz"*1?5%1<"Buzz"*+"#0?"1?_1<*!@"
"@'554***!#

Try it online!
How it works
0          Push 0 (accumulator).
'          Push a string that, when evaluated, does the following:
  1+         Increment the accumulator.
  0?         Push a copy.
  3%1<       Check if the remainder of its division by 3 is zero.
  "Fizz"*    Push "Fizz" for True, "" for False.
  1?         Push another copy of the accumulator.
  5%1<       Check if the remainder of its division by 5 is zero.
  "Buzz"*    Push "Buzz" for True, "" for False.
  +          Concatenate the potential fizzes and buzzes.
  "          Push a string that, when evaluated, does the following:
    #          Discard the topmost stack item.
    0?         Push a copy of the item below it (accumulator).
  "
  1?         Push a copy of the concatenation.
  _1<        Check if its length is zero.
  *!         Execute "#0?" once for True, zero times for False.
  @          Swap the generated output with the accumulator.
  "          Push "\n".
  "
  @          Swap it with the accumulator.
'
554**      Push 5 * 5 * 4 = 100.
*!         Execute the '...' string 100 times.
#          Discard the accumulator.

Javascript ES6, 77 chars
"\n".repeat(100).replace(/(?=\n)/g,(m,i)=>(++i%3?m:"Fizz")+(i%5?m:"Buzz")||i)

Test:
"\n".repeat(100).replace(/(?=\n)/g,(m,i)=>(++i%3?m:"Fizz")+(i%5?m:"Buzz")||i) == document.querySelector("pre").textContent

Here's my ES6 attempt, with parts stolen from yours (89 chars): "0".repeat(99).split(0).map((m,i)=>{return(++i%3?m:"Fizz")+(i%5?m:"Buzz")||i}).join("\n")

@starbeamrainbowlabs, why do you use {return ...} instead of expression?

Because I couldn't get the expression to work :(

Save a byte by using template strings + literal newline at front.

///, 229 bytes
/x/Buzz//b/
x//f/
Fizz/1
2f
4bf
7
8fb
11f
13
14fx
16
17f
19bf
22
23fb
26f
28
29fx
31
32f
34bf
37
38fb
41f
43
44fx
46
47f
49bf
52
53fb
56f
58
59fi
61
62f
64bf
67
68fb
71f
73
74fx
76
77f
79bf
82
83fb
86f
88
89fx
91
92f
94bf
97
98fb

Out-golfed

@Challenger5 Well done.

@LeakyNum I have A CJam script that finds common substrings in the input. It's useful for /// golfing.

JavaScript (using external library) (90 bytes)
x=>_.Range(1,100).Select(x=>x%3==0?(x%5==0?"FizzBuzz":"Fizz"):x%5==0?"Buzz":x).WriteLine()

Link to library: https://github.com/mvegh1/Enumerable/
Code explanation: Creates a range starting at 1 and extending 100 elements. Select maps the item according to the predicate. First check if divisible by 3, if so check if divisible by 5. If so, select "FizzBuzz", else select "Fizz". Otherwise,check if divisible by 5. If so, select "Buzz", else just select the number. WriteLine is built into the library, and it writes each element on its own line

DUP, 76 bytes
[$$3/%$[]['F,'i,'z,'z,]?\5/%$[]['B,'u,'z,'z,]?*[$.][]?10,]c:0[$100<][1+c;!]#
Explanation of program flow, code blocks:
DUP has two default truth values: -1 (true, all bits set) and 0 (false, no bits set). For conditional evaluations every nonzero value is accepted as true, comparisons themselves lead to either -1 or 0.
DUP has two conditional expressions, if-then-else and a while loop:
[execute if not false][execute if false]?. E.g. 1['t,]['f,]? prints t to STDOUT, because 1 is not false.
[condition][execute while not false]#. E.g. 5[$0>][$.1-]# prints the numbers 5,4,3,2,1 to STDOUT. The condition block tests the top stack value if it’s greater than 0, the execute block prints the number and decrements it.
The condition that’s checked is always the topmost stack element, which gets popped off the stack during the check.
[
    $$3/%$                              {dup,dup,push 3, moddiv, pop, dup}
    []                                  {if condition true do nothing}
      ['F,'i,'z,'z,]?                   {if condition false print Fizz}
    \5/%$                               {swap, push 5, moddiv, pop, dup}
    []                                  {if condition true do nothing}
      ['B,'u,'z,'z,]?                   {if condition false print Buzz}
    *                                   {mul}
    [$.]                                {if condition true dup, print to STDOUT}
        []?                             {if condition false do nothing}
    10,                                 {push 10, print char to STDOUT (newline)}
]c:                                     {define function c}

0                                       {push 0}

[$100<]                                 {while dup < push 100 true}
       [1+c;!]#                         {do push 1, add, execute function c}

Step by step:
instruction             stack
0                       0
[
$                       0,0
100                     0,0,100
<                       0,-1
]                       0
[
1                       0,1
+                       1               increment counter
c;                      1,0             0=start address of function c
!                       execute c
[
$$3                     1,1,1,3
/                       1,1,1,0         mod,div operator (n mod 3, n div 3)
%                       1,1,1           /% → mod
$                       1,1,1,1         result of n%3 used as flag for later check
[]                      1,1,1           condition true→do nothing
['F,'i,'z,'z,]?                         skipped
\                       1,1,1           swap top and 2nd stack elements
5                       1,1,1,5
/                       1,1,1,0         mod,div operator
%                       1,1,1           /% → mod
$                       1,1,1,1         n%5 flag
[]                      1,1,1           condition true → do nothing
['B,'u,'z,'z,]?                         skipped
*                       1,1             multiply %3 and %5 flags, result is only >0
                                        if neither %3 nor %5 are 0.
[                       1               if condition (flag)>0
 $                      1,1             dup
  .]                    1               print number to STDOUT: '1'
[]?                                     skipped

back to while loop

[
$                       1,1
100                     1,1,100
<                       1,-1
]                       1
[
1                       1,1
+                       2               increment counter
c;                      2,0             0=start address of function c
!                       execute c

...

A full description of all operators and program flow can be found at my GitHub repository, together wtih my Julia interpreter of DUP.
An online Javascript implementation showing useful debug information can be found here.
A rather terse introduction can be found on the esolangs.org DUP page.

///, 209 208 bytes
/I/
EFizz
//H/FizzE//G/
Fizz
//E/Buzz
/1
2G4I7
8GE11G13
14
H16
17G19I22
23GE26G28
29
H31
32G34I37
38GE41G43
44
H46
47G49I52
53GE56G58
59
H61
62G64I67
68GE71G73
74
H76
77G79I82
83GE86G88
89
H91
92G94I97
98GBuA

is it just me or is some of this redundant? there isn't much point in shortening Buzz to BuC if the bytes saved by that in general are less than the bytes added

Fourier, 81 bytes
|`Fizz`|F|`Buzz`|B1~i100(i~X%15{0}{1~XFB}X%5{0}{1~XB}X%3{0}{1~XF}X{i}{Xo}10ai^~i)

Try it on FourIDE
Who knew such a simple task would yield such a mammoth of a program!
Pseudocode of the program:
Function F {
    Print "Fizz"
}

Function B {
    Print "Buzz"
}

i = 1
While i != 100
    X = i
    If X % 15 == 0
        X = 1
        Function F
        Function B
    End if
    If X % 5 == 0
        X = 1
        Function B
    End If
    If X % 3 == 0
        X = 1
        Function F
    End If
    If X == i
        Print X
    End if
    Print "\n"
    i += 1
End while

you say function a in the ungolfed, do you mean function F?

also I don't think you get to call it mammoth if it fits on screen in one line, and the challenge actually isn't that simple

S.I.L.O.S, 141 bytes
lbla
a+1
c=1-(a%3)*(a%5)
if c b
printIntNoLine a
lblb
c=(a%3)
if c d
print Fizz
lbld
c=(a%5)
if c c
print Buzz
lblc
printLine
b=100-a
if b a

Try it online!
Unfortunately SILOS is incredibly verbose, and an interpreter bug cost me a few extra bytes, but I think SILOS is "superior" only to scratch in this challenge.

Micro, 72 bytes
:i{i1+:i"":d
i3/i3%=if("Fizz":d,)
i5/i5%=if(d"Buzz"+:d,)
d:\i100=if(,a)}

Jq 1.5, 90 bytes
def f:if.%15<1then"FizzBuzz"elif.%5<1then"Buzz"elif.%3<1then"Fizz"else. end;range(100)+1|f

Try it online!

Modula-2, 222 bytes
MODULE F;IMPORT InOut;VAR i:INTEGER;BEGIN
FOR i:=1 TO 100 DO
CASE i*i*i*i MOD 15 OF
0:InOut.WriteString("FizzBuzz")|1:InOut.WriteInt(i,0)|6:InOut.WriteString("Fizz")|10:InOut.WriteString("Buzz")END;InOut.WriteLn
END END F.

Tested with Amsterdam Compiler Kit.  The program needs 4-byte INTEGER.  If using 2-byte INTEGER, i*i*i*i overflows and the program fails with a case error.
With indentation:
MODULE F;
IMPORT InOut;
VAR i: INTEGER;
BEGIN
  FOR i := 1 TO 100 DO
    CASE i * i * i * i MOD 15 OF
      0: InOut.WriteString("FizzBuzz")
    | 1: InOut.WriteInt(i, 0)
    | 6: InOut.WriteString("Fizz")
    | 10: InOut.WriteString("Buzz")
    END;
    InOut.WriteLn
  END
END F.

ACK compiles the PIM3 dialect of Modula-2 and comes with an InOut module.  Other compilers for Modula-2 or Oberon might have shorter syntax or come with shorter modules.

I don't like having 3 calls to InOut.WriteString, but adding a PROCEDURE p(s:ARRAY OF CHAR);BEGIN InOut.WriteString(s)END p; would cost 61 bytes and save only 48 bytes in the calls.
I would write FOR i:=1TO 100DO but ACK rejects it as a syntax error.
I had used i*i*i*i MOD 15 in my AppleScript answer.

MY-BASIC, 116 bytes
A basic response.
For i=1 To 100
S=""
If i Mod 3=0 Then S="Fizz"
If i Mod 5=0 Then S=S+"Buzz"
If S="" Then Print i; Else Print S;
Next

Try it online!

Ada (GNAT), 196 bytes
procedure GNAT.IO.F is begin for I in Integer range 1..100 loop Put((if I mod 3=0 then"Fizz"else"")&(if I mod 5=0 then"Buzz"else""));if I mod 3*I mod 5/=0 then Put(I);end if;New_Line;end loop;end;

Try it online!
189 bytes if extraneous whitespace is allowed:
procedure GNAT.IO.F is begin for I in Integer range 1..100 loop Put(if I mod 3=0 then(if I mod 5=0 then"FizzBuzz"else"Fizz")else(if I mod 5=0 then"Buzz"else I'Image));New_Line;end loop;end;

Try it online!

05AB1E, 25 bytes
тLv”FizzÒÖ”#y3 5‚ÖÏJy‚éθ,

Try it online!
I figured I'd add a fourth 05AB1E answer to this challenge. This uses my favourite "vectorise is-divisible and then repeat the fizbuzz list accordingly" approach.
Explained
тLv”FizzÒÖ”#y3 5‚ÖÏJy‚éθ,
тL                        # The range 1 .. 100
  v                       # For each N in that range:
   ”FizzÒÖ”#              #     Push the list ["Fizz", "Buzz"]
            y3 5‚Ö        #     Push N % [3, 5] == 0 (vectorised)
                  Ï       #     "Multiply" the two lists as you would in Vyxal
                   J      #     And concatenate that into a single string
                    y‚    #     And pair that with N
                      é   #     Sorting that by length, so that the value we want is always last
                       θ, #     And print it with a newline

D, 115 bytes
import std;void main(){string x;for(int i;i++<100;x=((i%3?"":"Fizz")~(i%5?"":"Buzz")),writeln(x?x:i.to!string)){};}

Try it online!
Adapted from this code:
import std;void main(){auto fizzbuzz(in uint i){string r;if(i%3==0)r~="Fizz";if(i%5==0)r~="Buzz";if(r.length==0)r~=i.to!string;return r;}enum r=1.iota(101).map!fizzbuzz;r.each!writeln;}

Fortran (GFortran), 187 bytes
DO I=1,100
IF(MOD(I,3)==0.AND.MOD(I,5)==0)THEN;PRINT'(A)','FizzBuzz'
ELSEIF(MOD(I,3)==0)THEN;PRINT'(A)','Fizz'
ELSEIF(MOD(I,5)==0)THEN;PRINT'(A)','Buzz'
ELSE;PRINT'(I0)',I
ENDIF;ENDDO;END

Try it online!

very similar to the fortran solution from 2017...  https://codegolf.stackexchange.com/a/137403/15940

Nim, 72 bytes
for i in 1..100:echo max(["Fizz",""][i*i%%3]&["Buzz",""][ord i%%5>0],$i)

Try it online!

Pascal (FPC), 180 bytes
program f(o);var i:integer;begin for i:=1to 100do if i mod 15=0then writeln('FizzBuzz')else if i mod 3=0then writeln('Fizz')else if i mod 5=0then writeln('Buzz')else writeln(i)end.

Try it online!

Prolog (SWI), 225 229 165 bytes
f(N,'FizzBuzz'):-N mod 15<1. f(N,'Fizz'):-N mod 3<1,N mod 5>0. f(N,'Buzz'):-N mod 3>0,N mod 5<1. f(N,N):-N mod 3>0,N mod 5>0. :-between(1,100,X),f(X,Y),\+writeln(Y).

Try it online!
Thanks to @JoKing (redundant init and h), I lost 64 bytes!
:-initialization m. f(N,'FizzBuzz'):-N mod 3=:=0,N mod 5=:=0. f(N,'Fizz'):-N mod 3=:=0,N mod 5=\=0. f(N,'Buzz'):-N mod 3=\=0,N mod 5=:=0. f(N,N):-N mod 3=\=0,N mod 5=\=0. m:-between(1,100,X),f(X,Y),write(Y),nl,fail,h(0). m:-h(1).

What is the point of the h calls? also the initialization part? Some simple golfing for 165 bytes (though it can be half the size)

@JoKing Sorry, I'm not that good at Prolog. I got really into it one day but then lost interest in it. Thanks for the tip!

Morse Code, 1777 bytes
.---- / ..--- / ..-. .. --.. --.. / ....- / -... ..- --.. --.. / ..-. .. --.. --.. / --... / ---.. / ..-. .. --.. --.. / -... ..- --.. --.. / .---- .---- / ..-. .. --.. --.. / .---- ...-- / .---- ....- / ..-. .. --.. --.. -... ..- --.. --.. / .---- -.... / .---- --... / ..-. .. --.. --.. / .---- ----. / -... ..- --.. --.. / ..-. .. --.. --.. / ..--- ..--- / ..--- ...-- / ..-. .. --.. --.. / -... ..- --.. --.. / ..--- -.... / ..-. .. --.. --.. / ..--- ---.. / ..--- ----. / ..-. .. --.. --.. -... ..- --.. --.. / ...-- .---- / ...-- ..--- / ..-. .. --.. --.. / ...-- ....- / -... ..- --.. --.. / ..-. .. --.. --.. / ...-- --... / ...-- ---.. / ..-. .. --.. --.. / -... ..- --.. --.. / ....- .---- / ..-. .. --.. --.. / ....- ...-- / ....- ....- / ..-. .. --.. --.. -... ..- --.. --.. / ....- -.... / ....- --... / ..-. .. --.. --.. / ....- ----. / -... ..- --.. --.. / ..-. .. --.. --.. / ..... ..--- / ..... ...-- / ..-. .. --.. --.. / -... ..- --.. --.. / ..... -.... / ..-. .. --.. --.. / ..... ---.. / ..... ----. / ..-. .. --.. --.. -... ..- --.. --.. / -.... .---- / -.... ..--- / ..-. .. --.. --.. / -.... ....- / -... ..- --.. --.. / ..-. .. --.. --.. / -.... --... / -.... ---.. / ..-. .. --.. --.. / -... ..- --.. --.. / --... .---- / ..-. .. --.. --.. / --... ...-- / --... ....- / ..-. .. --.. --.. -... ..- --.. --.. / --... -.... / --... --... / ..-. .. --.. --.. / --... ----. / -... ..- --.. --.. / ..-. .. --.. --.. / ---.. ..--- / ---.. ...-- / ..-. .. --.. --.. / -... ..- --.. --.. / ---.. -.... / ..-. .. --.. --.. / ---.. ---.. / ---.. ----. / ..-. .. --.. --.. -... ..- --.. --.. / ----. .---- / ----. ..--- / ..-. .. --.. --.. / ----. ....- / -... ..- --.. --.. / ..-. .. --.. --.. / ----. --... / ----. ---.. / ..-. .. --.. --.. / -... ..- --.. --..

Raku, 44 bytes
say 'Fizz'x$_%%3~'Buzz'x$_%%5||$_ for 1..100

Try it online!

V (vlang.io), 137 bytes
fn main(){for i in 1..101{if i%15==0{println('FizzBuzz')}else if i%3==0{println('Fizz')}else if i%5==0{println('Buzz')}else{println(i)}}}

Try it online!
Ungolfed code:
fn main () {
  mut i := 1
  for i < 101 {
    match true {
      i % 15 == 0 {
        println('FizzBuzz')
      } i % 3 == 0 {
        println('Fizz')
      } i % 5 == 0 {
        println('Buzz')
      } else {
        println(i)
      }
    }
    i++
  }
}

Fig, \$31\log_{256}(96)\approx\$ 25.517 bytes
jcnnna100 5'"Buzz"3'FOa9+"Fizz"

Try it online!
Hmm yes irrational bytes. "It'll be shorter" they said. "It's the future of golf".
8.5 bytes longer than legitimate vybuzz, 5.5 more than Jelly, 15.5 more than the optimal vybuzz/Fact fizzbuzz.
Explained
jcnnna100 5'"Buzz"3'FOa9+"Fizz"
    na100 5'"Buzz"               # Every 5th item of the range [1, 100] replaced with "Buzz"
   n              3'             # To every 3rd item of that:
                        +"Fizz"  #   Prepend the word "Fizz"
                    FOa9         #   And remove all digits from it. This should just be FcD (because cD is allegedly all digits), but turns out that cD is [A-z0-9], which is allegedly what cN is supposed to be, but cN errors out. Thanks Seggan very cool.
jcn                              # Join all that on newlines

Not amused. After fixing about 8 bugs I got the n solution one char shorter smh

this prints BuzzFizz

@Seggan well the jokes on you because I got it 3 characters shorter

Golfing in somebody else's language as a means of bragging about your own language is in very poor taste, IMO.

@DLosc maybe, but in this case, it's more along the lines of friendly banter

Okay, but I'd say the return banter belongs in your Vyxal answer, not here.

Woops, cD is actually cd

Convex, 35 bytes
A²´{__3%!"Fizz"*\5%!"Buzz"*+\e|}%N*

Try it online!
Why must older golfing languages not having automatically vectorising operations?
Explained
A²´{__3%!"Fizz"*\5%!"Buzz"*+\e|}%N*
A²´{                           }%   e# to the range [1, 100]:
    __                              e#   Triplicate the item
      3%!"Fizz"*                    e#   Repeat the string "Fizz" (!item % 3) times
                \5%!"Buzz"*         e#   Repeat the string "Buzz" (!item % 5) times
                           +\e|     e#   Add the two strings together and logical or with the item
                                 N* e# Join that on newlines

vemf, 33 bytes
d↨╕{╞"Fizz""Buzz"‼╞αó35,X·x≈?x◘αⁿ

A new language, a new fizzbuzz. 5 bytes longer than the one in the repo.
Explained
d↨╕{╞"Fizz""Buzz"‼╞αó35,X·x≈?x◘αⁿ
d↨╕{                               # To each number n in the range 1..100
                   αó35            # [n % 3 == 0, n % 5 == 0]
     "Fizz""Buzz"‼                 # ["Fizz" if n % 3 == 0, "Buzz" if n % 5 == 0]
                       ,           # flatten
                        X          # and store in variable x
                         ·x≈?      # is there stuff in x?
                             x◘αⁿ  # yes: return x, else: return str(n)

Minecraft Function, 666 bytes
scoreboard objectives add c dummy
scoreboard players add c c 1
scoreboard players set 0 c 0
scoreboard players set 3 c 3
scoreboard players set 5 c 5
scoreboard players operation f c = c c
scoreboard players operation b c = c c
scoreboard players operation f c %= 3 c
scoreboard players operation b c %= 5 c
execute if score f c > 0 c if score b c > 0 c run tellraw @a {"score":{"name":"c","objective":"c"}}
execute if score f c = 0 c if score b c > 0 c run tellraw @a "Fizz"
execute if score f c > 0 c if score b c = 0 c run tellraw @a "Buzz"
execute if score f c = 0 c if score b c = 0 c run tellraw @a "FizzBuzz"
execute if score c c matches ..99 run function a:b

Must be run as a function named a in a data pack named b. I think this is about optimal for a scoreboard based solution.
Commented version:
# Create scoreboard to store variables
scoreboard objectives add c dummy
# Increment counter by 1 (starts at 0)
scoreboard players add c c 1
# Set constants 0, 3, and 5 for comparison and modulo
scoreboard players set 0 c 0
scoreboard players set 3 c 3
scoreboard players set 5 c 5

# Copy value of counter to f and b and modulo them by 3 and 5 respectively.
scoreboard players operation f c = c c
scoreboard players operation b c = c c
scoreboard players operation f c %= 3 c
scoreboard players operation b c %= 5 c

# If f and b are both > 0, print the counter
execute if score f c > 0 c if score b c > 0 c run tellraw @a {"score":{"name":"c","objective":"c"}}
# If f = 0 and b > 0, print Fizz
execute if score f c = 0 c if score b c > 0 c run tellraw @a "Fizz"
# If f > 0 and b > 0, print Buzz
execute if score f c > 0 c if score b c = 0 c run tellraw @a "Buzz"
# If both are 0 print FizzBuzz (Minecraft doesn't support string concatenation so this is necessary)
execute if score f c = 0 c if score b c = 0 c run tellraw @a "FizzBuzz"
# Run the function again if the counter is <= 99
execute if score c c matches ..99 run function a:b

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