Choose a version:
29% The original file has 1840745 bytes (1,797.6k) and is available from the project website.
There you can find the official minified version, too, which brings down the size to 525743 bytes (513.4k, 29%).

After GZIP compression these minified files vary in size:
Boot
  162209 bytes (158.4k)
CDN
cdnjs
  132419 bytes (129.3k)
CDN
gzip -6 (default)
  130616 bytes (127.6k)
local copy
gzip -9
  130142 bytes (127.1k)
local copy
7zip -mx=9 -tgzip
  125632 bytes (122.7k)
local copy
libdeflate -12
  125486 bytes (122.5k)
local copy
pigz -11 -n
  125351 bytes (122.4k)
local copy
kzip -s0 -rn -b5
  125146 bytes (122.2k)
local copy
Zopfli
  125107 bytes (122.2k)
local copy
Zopfli (defluff)
  125104 bytes (122.2k)
local copy

perma-link to the smallest file on my server:
http://minime.stephan-brumme.com/files/ember/ember-2.10.2.min.js (or via HTTPS)

You will automatically get the smallest Ember 2.10.2 file, ETag caching is available and
if your browser doesn't support GZIP decompression then the uncompressed version will be sent.

Currently best Zopfli settings

Save 7312 bytes by using my Ember 2.10.2 Zopfli version instead of the best available CDN (5.84% smaller than cdnjs, 125107 vs. 132419 bytes):
You can use my super-compressed files for whatever purpose you like as long as you respect the library's original license agreement.
There are no restrictions from my side - but please avoid hot-linking if you run a high-traffic website.

These command-line settings yielded the best compression ratio so far (Linux version of zopfli-krzymod):
zopfli --i100000 --mb8 --mls16384 --bsr4 --lazy --ohh

(found December 20, 2016)
Description Value Parameter
iterations 100000  --i100000
maximum blocks 8  --mb8
maximum length score 16384  --mls16384
block splitting recursion 4  --bsr4
lazy matching in LZ77 yes  --lazy
optimized Huffman headers yes  --ohh
initial random W for iterations 1  --rw1
initial random Z for iterations 2  --rz2

Even Smaller Files Thanks To Defluff

Zopfli's output can be further optimized by the defluff tool.
In this particular case, defluff saves 3 more bytes (125104 bytes).

Verify file integrity

After decompression, my uncompressed files are identical to the original ones:

MD5:
curl --silent --compressed https://builds.emberjs.com/tags/v2.10.2/ember.min.js --location | md5sum
7b4cc5c4ba147c5bf48f0b780a77d531  -
curl --silent --compressed https://minime.stephan-brumme.com/files/ember/ember-2.10.2.min.zopfli.js.gz | md5sum
7b4cc5c4ba147c5bf48f0b780a77d531  -

SHA1:
curl --silent --compressed https://builds.emberjs.com/tags/v2.10.2/ember.min.js --location | sha1sum
b08379e8e3a2e89d2715b98c1e27fa5d0d5e8fa7  -
curl --silent --compressed https://minime.stephan-brumme.com/files/ember/ember-2.10.2.min.zopfli.js.gz | sha1sum
b08379e8e3a2e89d2715b98c1e27fa5d0d5e8fa7  -

All listed CDNs deliver identical contents:
CDN Size (compressed) MD5 (uncompressed) Timestamp
Boot 162209 bytes 7b4cc5c4ba147c5bf48f0b780a77d531 December 20, 2016 @ 06:21
cdnjs 132419 bytes 7b4cc5c4ba147c5bf48f0b780a77d531 December 20, 2016 @ 01:17

Note: only the MD5 hashes are shown to keep things simple.

Other Versions

Available Ember versions at minime.stephan-brumme.com:

3.0.0,
2.18.2, 2.18.1, 2.18.0,
2.17.2, 2.17.1, 2.17.0,
2.16.2, 2.16.1, 2.16.0,
2.15.3, 2.15.2, 2.15.1, 2.15.0,
2.14.1, 2.14.0,
2.13.4, 2.13.3, 2.13.2, 2.13.1, 2.13.0,
2.12.2, 2.12.1, 2.12.0,
2.11.3, 2.11.2, 2.11.1, 2.11.0,
2.10.2, 2.10.1, 2.10.0,
2.9.1, 2.9.0,
2.8.3, 2.8.2, 2.8.1, 2.8.0,
2.7.3, 2.7.2, 2.7.1, 2.7.0,
2.6.2, 2.6.1, 2.6.0,
2.5.1, 2.5.0,
2.4.6, 2.4.5, 2.4.4, 2.4.3, 2.4.2, 2.4.1, 2.4.0,
2.3.1, 2.3.0,
2.2.2, 2.2.1, 2.2.0,
2.1.2, 2.1.1, 2.1.0,
2.0.3, 2.0.2, 2.0.1, 2.0.0,
1.13.13, 1.13.12, 1.13.11, 1.13.10, 1.13.9, 1.13.8, 1.13.7, 1.13.6, 1.13.5, 1.13.4, 1.13.3, 1.13.2, 1.13.1, 1.13.0,
1.12.2, 1.12.1, 1.12.0,
1.11.4, 1.11.3, 1.11.2, 1.11.1, 1.11.0,
1.10.1, 1.10.0,
1.9.1, 1.9.0,
1.8.1, 1.8.0,
1.7.1, 1.7.0,
1.6.1, 1.6.0,
1.5.1, 1.5.0,
1.4.0,
1.3.2, 1.3.1, 1.3.0,
1.2.2, 1.2.1, 1.2.0,
1.0.1, 1.0.0

The project site contains an overview how well these versions were compressed.
Other interesting projects are AngularJS, BackboneJS, Bootstrap, D3, Dojo, jQuery, Knockout, lodash, React, Socket.IO, ThreeJS, UnderscoreJS and Vue.

Changelog

Best Zopfli parameters so far:
Size Improvement Parameters Found
125107 bytes -5 bytes zopfli --i100000 --mls16384 --bsr4 --lazy --ohh December 20, 2016 @ 17:06
125112 bytes -12 bytes zopfli --i10000 --mls16384 --bsr4 --lazy --ohh December 20, 2016 @ 14:17
125124 bytes -18 bytes zopfli --i1000 --mls16384 --bsr4 --lazy --ohh December 20, 2016 @ 13:59
125142 bytes zopfli --i100 --mls16384 --bsr4 --lazy --ohh December 20, 2016 @ 13:46

If there are multiple parameter sets yielding the same compressed size, only the first one found is shown.

Most recent activity on January 25, 2017 @ 15:26.

Heatmaps

This Zopfli heatmap visualizes how compression changes when modifying the --bsr and --mls parameter.
Cell's contents is the best filesize achieved (in bytes, hover with mouse over cells to see number of iterations).

Good parameters are green, bad are red. The best and worst are bold as well.
The brightness of the blue background color indicates how many iterations were processed:
10,000 or 100,000.
bsr \ mls
2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768
bsr \ mls
2 4 8 16 32 64 128 256 512 1024 2048 4096 8192 16384 32768
125257 125254 125255 125255 125254 125255 125252 125166 125166 125215 125248 125257 125255 125201 125254
125181 125175 125180 125255 125254 125255 125252 125169 125172 125138 125153 125257 125255 125107 125254
125191 125193 125192 125201 125201 125193 125193 125195 125177 125154 125148 125144 125168 125131 125188
125129 125134 125176 125195 125193 125200 125202 125193 125162 125203 125140 125257 125255 125131 125196
125193 125193 125191 125193 125193 125193 125196 125194 125157 125146 125164 125257 125255 125182 125184
125137 125189 125191 125193 125193 125190 125192 125193 125178 125144 125151 125133 125174 125133 125185
125192 125203 125191 125191 125193 125192 125229 125193 125179 125141 125139 125130 125177 125137 125184
125191 125191 125189 125201 125193 125191 125191 125193 125175 125142 125133 125172 125180 125131 125185
125191 125201 125200 125193 125194 125193 125192 125192 125175 125135 125151 125171 125177 125183 125190
125190 125196 125196 125193 125193 125193 125229 125195 125177 125145 125145 125168 125180 125131 125185
125134 125133 125192 125195 125184 125186 125189 125194 125177 125171 125140 125176 125186 125131 125191
125190 125192 125192 125193 125193 125190 125190 125192 125175 125135 125135 125139 125180 125184 125203
125192 125190 125192 125200 125193 125193 125187 125193 125174 125139 125136 125149 125190 125131 125191
125191 125191 125202 125194 125193 125193 125192 125193 125177 125145 125147 125128 125175 125131 125205
125191 125192 125200 125193 125192 125193 125229 125192 125177 125139 125138 125171 125171 125184 125184
125191 125197 125191 125192 125193 125203 125190 125194 125177 125139 125152 125140 125174 125135 125185
125130 125134 125192 125193 125193 125201 125192 125194 125186 125145 125150 125134 125177 125133 125239
125191 125201 125194 125201 125196 125193 125192 125201 125175 125141 125161 125134 125177 125133 125183
125191 125201 125194 125192 125193 125191 125192 125192 125174 125140 125138 125138 125171 125129 125185
125192 125203 125192 125196 125200 125191 125186 125193 125175 125140 125135 125171 125180 125132 125185
125190 125192 125192 125194 125191 125190 125229 125193 125176 125138 125139 125136 125176 125134 125191
125191 125190 125190 125191 125200 125189 125190 125195 125175 125149 125135 125169 125171 125132 125184
125191 125201 125194 125192 125193 125193 125190 125193 125201 125142 125155 125137 125174 125184 125191

Due to the Monte Carlo design of my search algorithm, not all parameters have reached the same number of iterations yet:
Iterations Min. Bytes Reduction Coverage
100 125142 bytes 100%
1,000 125124 bytes -18 bytes 100%
10,000 125112 bytes -12 bytes 100%
100,000 125107 bytes -5 bytes 0.29%
1,000,000
10,000,000

KZIP has far less options available for tuning/optimization. I only played around with the number of blocks (parameter -n):
Blocks Min. Bytes Compared To Best Zopfli Compared To Best KZIP
125211 bytes +104 bytes (+0.08%) +65 bytes
125243 bytes +136 bytes (+0.11%) +97 bytes
125254 bytes +147 bytes (+0.12%) +108 bytes
125265 bytes +158 bytes (+0.13%) +119 bytes
125194 bytes +87 bytes (+0.07%) +48 bytes
125146 bytes +39 bytes (+0.03%)
125211 bytes +104 bytes (+0.08%) +65 bytes
125222 bytes +115 bytes (+0.09%) +76 bytes
125277 bytes +170 bytes (+0.14%) +131 bytes

Non-DEFLATE Algorithms

Archivers based on completely different compression algorithms often produce superior results.
Unfortunately, browsers only support gzip compression at the moment.
However, support for Brotli is constantly growing - but your browser doesn't support it.
Algorithm Program Parameters Size Compared To Best Zopfli
ZPAQ (Wikipedia) zpaq zpaq -method 69 84898 bytes -40209 bytes (-32.14%)
RAR (proprietary) RAR rar a -m5 -md64m -mc63:128t -mt1 91798 bytes -33309 bytes (-26.62%)
PPMd (Wikipedia) 7zip 7za a -mx=9 -m0=ppmd 95350 bytes -29757 bytes (-23.79%)
Burrows-Wheeler transform (Wikipedia) bzip2 bzip2 -9 105309 bytes -19798 bytes (-15.82%)
Brotli (Wikipedia) brotli brotli -q 11 109006 bytes -16101 bytes (-12.87%)
LZMA2 (Wikipedia) xz xz -9 110956 bytes -14151 bytes (-11.31%)
Zstandard (Wikipedia) zstd zstd -19 114293 bytes -10814 bytes (-8.64%)

Detailled Analysis

I wrote a DEFLATE decoder in Javascript. Click the button below to start a client-side analysis of the smallest gzipped files (may take a second):


Notes: pigz is a fast open source multi-threaded implementation of gzip written by one of the original authors of gzip.
However, when using compression level 11, pigz actually switches to the slower Zopfli algorithm and isn't multi-threaded anymore.
KrzyMOD's extensions to Zopfli offer the highest level of configuration and is therefore used for my brute-force search.
Ken Silverman wrote the closed-source KZIP compression program and Jonathon Fowler ported it to Linux.
Defluff was created by Joachim Henke; DeflOpt is a tool by Ben Jos Walbeehm.

website made by Stephan Brumme in 2015 and still improving in 2018.
all timestamps are displayed in central european time. see my changelog.
no flash, not even images or external css files - and everything squeezed into a single html file.
which was handsomely compressed before releasing it into the wild internet - obviously.

please visit my homepage and my blog, too.
email: minime (at) stephan-brumme.com