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

After GZIP compression these minified files vary in size:
Boot
  162253 bytes (158.5k)
CDN
cdnjs
  132446 bytes (129.3k)
CDN
gzip -6 (default)
  130650 bytes (127.6k)
local copy
gzip -9
  130174 bytes (127.1k)
local copy
7zip -mx=9 -tgzip
  125610 bytes (122.7k)
local copy
libdeflate -12
  125510 bytes (122.6k)
local copy
pigz -11 -n
  125386 bytes (122.4k)
local copy
kzip -s0 -rn -b5
  125173 bytes (122.2k)
local copy
Zopfli
  125130 bytes (122.2k)
local copy
Zopfli (defluff)
  125128 bytes (122.2k)
local copy

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

You will automatically get the smallest Ember 2.10.1 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 7316 bytes by using my Ember 2.10.1 Zopfli version instead of the best available CDN (5.85% smaller than cdnjs, 125130 vs. 132446 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 14, 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 2 more bytes (125128 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.1/ember.min.js --location | md5sum
d40b464939f1b5e586311faf3ce6cab4  -
curl --silent --compressed https://minime.stephan-brumme.com/files/ember/ember-2.10.1.min.zopfli.js.gz | md5sum
d40b464939f1b5e586311faf3ce6cab4  -

SHA1:
curl --silent --compressed https://builds.emberjs.com/tags/v2.10.1/ember.min.js --location | sha1sum
47179fa56b8d987e1b9e1388531a08c76db3feda  -
curl --silent --compressed https://minime.stephan-brumme.com/files/ember/ember-2.10.1.min.zopfli.js.gz | sha1sum
47179fa56b8d987e1b9e1388531a08c76db3feda  -

All listed CDNs deliver identical contents:
CDN Size (compressed) MD5 (uncompressed) Timestamp
Boot 162253 bytes d40b464939f1b5e586311faf3ce6cab4 December 15, 2016 @ 07:04
cdnjs 132446 bytes d40b464939f1b5e586311faf3ce6cab4 December 14, 2016 @ 09:32

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
125130 bytes -9 bytes zopfli --i100000 --mls16384 --bsr4 --lazy --ohh December 14, 2016 @ 16:57
125139 bytes -3 bytes zopfli --i10000 --mls16384 --bsr9 --lazy --ohh December 14, 2016 @ 15:31
125142 bytes -10 bytes zopfli --i10000 --mls16384 --bsr4 --lazy --ohh December 14, 2016 @ 13:58
125152 bytes -2 bytes zopfli --i1000 --mls16384 --bsr4 --lazy --ohh December 14, 2016 @ 13:35
125154 bytes -20 bytes zopfli --i1000 --mls16384 --bsr9 --lazy --ohh December 14, 2016 @ 13:33
125174 bytes zopfli --i100 --mls16384 --bsr4 --lazy --ohh December 14, 2016 @ 13:17

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:30.

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
125280 125274 125280 125276 125276 125276 125274 125191 125188 125240 125272 125278 125274 125191 125276
125204 125200 125280 125276 125276 125276 125274 125190 125191 125155 125154 125278 125274 125130 125276
125214 125217 125217 125221 125226 125219 125217 125218 125199 125172 125171 125163 125189 125157 125205
125194 125151 125195 125221 125222 125216 125222 125217 125189 125232 125162 125278 125274 125156 125228
125217 125218 125215 125217 125216 125221 125216 125218 125203 125149 125177 125278 125195 125154 125213
125155 125213 125218 125217 125222 125217 125217 125222 125200 125153 125156 125158 125194 125135 125209
125215 125218 125218 125218 125216 125219 125214 125218 125200 125165 125145 125162 125199 125154 125210
125217 125217 125214 125220 125222 125218 125216 125217 125199 125164 125161 125160 125196 125156 125209
125218 125215 125215 125221 125222 125217 125217 125216 125193 125168 125183 125160 125194 125211 125206
125216 125216 125217 125216 125222 125216 125214 125218 125197 125163 125172 125192 125199 125154 125213
125155 125156 125217 125221 125211 125208 125213 125218 125200 125153 125165 125197 125199 125155 125206
125218 125214 125217 125216 125221 125213 125216 125217 125199 125170 125163 125155 125189 125212 125226
125216 125214 125217 125217 125218 125217 125211 125222 125194 125163 125175 125172 125192 125153 125214
125217 125215 125220 125222 125217 125214 125217 125219 125195 125166 125165 125152 125191 125155 125229
125216 125216 125215 125221 125222 125216 125214 125217 125198 125163 125164 125157 125191 125209 125210
125215 125215 125215 125218 125221 125217 125216 125220 125197 125170 125178 125162 125193 125193 125209
125154 125158 125217 125217 125222 125218 125216 125217 125203 125169 125175 125157 125197 125154 125225
125218 125215 125224 125224 125225 125222 125217 125221 125197 125175 125181 125158 125197 125159 125214
125218 125215 125218 125217 125221 125217 125216 125217 125216 125157 125165 125161 125195 125155 125209
125215 125218 125215 125216 125217 125217 125210 125218 125202 125162 125163 125157 125195 125156 125209
125214 125216 125217 125222 125222 125217 125214 125218 125197 125165 125166 125159 125195 125210 125214
125217 125215 125215 125216 125217 125214 125214 125217 125195 125168 125161 125156 125190 125156 125209
125218 125216 125215 125218 125217 125217 125216 125222 125217 125164 125169 125159 125192 125209 125208

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 125174 bytes 100%
1,000 125152 bytes -22 bytes 100%
10,000 125139 bytes -13 bytes 100%
100,000 125130 bytes -9 bytes 0.58%
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
125227 bytes +97 bytes (+0.08%) +54 bytes
125247 bytes +117 bytes (+0.09%) +74 bytes
125288 bytes +158 bytes (+0.13%) +115 bytes
125286 bytes +156 bytes (+0.12%) +113 bytes
125242 bytes +112 bytes (+0.09%) +69 bytes
125173 bytes +43 bytes (+0.03%)
125219 bytes +89 bytes (+0.07%) +46 bytes
125252 bytes +122 bytes (+0.10%) +79 bytes
125288 bytes +158 bytes (+0.13%) +115 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 84924 bytes -40206 bytes (-32.13%)
RAR (proprietary) RAR rar a -m5 -md64m -mc63:128t -mt1 91813 bytes -33317 bytes (-26.63%)
PPMd (Wikipedia) 7zip 7za a -mx=9 -m0=ppmd 95380 bytes -29750 bytes (-23.78%)
Burrows-Wheeler transform (Wikipedia) bzip2 bzip2 -9 105452 bytes -19678 bytes (-15.73%)
Brotli (Wikipedia) brotli brotli -q 11 109038 bytes -16092 bytes (-12.86%)
LZMA2 (Wikipedia) xz xz -9 110960 bytes -14170 bytes (-11.32%)
Zstandard (Wikipedia) zstd zstd -19 114343 bytes -10787 bytes (-8.62%)

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