Choose a version:
22% The original file has 668793 bytes (653.1k) and is available from the project website.
There you can find the official minified version, too, which brings down the size to 147112 bytes (143.7k, 22%).

After GZIP compression these minified files vary in size:
Boot
  51200 bytes (50.0k)
CDN
cdnjs
  43851 bytes (42.8k)
CDN
cdnhttps
  43442 bytes (42.4k)
CDN
unpkg
  43442 bytes (42.4k)
CDN
gzip -6 (default)
  43423 bytes (42.4k)
local copy
jsdelivr
  43349 bytes (42.3k)
CDN
gzip -9
  43236 bytes (42.2k)
local copy
libdeflate -12
  41783 bytes (40.8k)
local copy
7zip -mx=9 -tgzip
  41780 bytes (40.8k)
local copy
kzip -s0 -rn -b7
  41703 bytes (40.7k)
local copy
pigz -11 -n
  41695 bytes (40.7k)
local copy
Zopfli
  41528 bytes (40.6k)
local copy
Zopfli (defluff)
  41527 bytes (40.6k)
local copy

perma-link to the smallest file on my server:
http://minime.stephan-brumme.com/files/react/react-15.1.0.min.js

You will automatically get the smallest React 15.1.0 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 1821 bytes by using my React 15.1.0 Zopfli version instead of the best available CDN (4.38% smaller than jsdelivr, 41528 vs. 43349 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 --i1000000 --mb8 --mls32 --bsr18 --lazy --ohh

(found May 23, 2016)
Description Value Parameter
iterations 1000000  --i1000000
maximum blocks 8  --mb8
maximum length score 32  --mls32
block splitting recursion 18  --bsr18
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 1 more byte (41527 bytes).

Verify file integrity

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

MD5:
curl --silent --compressed https://fb.me/react-15.1.0.min.js --location | md5sum
e4c416eda4f8e6789efc4ba4d716c7cc  -
curl --silent --compressed http://minime.stephan-brumme.com/files/react/react-15.1.0.min.zopfli.js.gz | md5sum
e4c416eda4f8e6789efc4ba4d716c7cc  -

SHA1:
curl --silent --compressed https://fb.me/react-15.1.0.min.js --location | sha1sum
34c5e74b12ccaad6d6aa136fb0c2d03ac68cf5e5  -
curl --silent --compressed http://minime.stephan-brumme.com/files/react/react-15.1.0.min.zopfli.js.gz | sha1sum
34c5e74b12ccaad6d6aa136fb0c2d03ac68cf5e5  -

All listed CDNs deliver identical contents:
CDN Size (compressed) MD5 (uncompressed) Timestamp
Boot 51200 bytes e4c416eda4f8e6789efc4ba4d716c7cc May 21, 2016 @ 05:38
cdnjs 43851 bytes e4c416eda4f8e6789efc4ba4d716c7cc May 21, 2016 @ 01:16
cdnhttps 43442 bytes e4c416eda4f8e6789efc4ba4d716c7cc November 22, 2016 @ 16:40
unpkg 43442 bytes e4c416eda4f8e6789efc4ba4d716c7cc July 11, 2016 @ 15:32
jsdelivr 43349 bytes e4c416eda4f8e6789efc4ba4d716c7cc May 21, 2016 @ 01:05

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

Other Versions

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

16.3.1, 16.3.0,
16.2.0,
16.1.1, 16.1.0, 16.0.0,
15.6.2, 15.6.1, 15.6.0,
15.5.2, 15.5.1, 15.5.0,
15.4.2, 15.4.1, 15.4.0,
15.3.2, 15.3.1, 15.3.0,
15.2.1, 15.2.0,
15.1.0,
15.0.2, 15.0.1, 15.0.0,
0.14.8, 0.14.7, 0.14.6, 0.14.5, 0.14.4, 0.14.3, 0.14.2, 0.14.1, 0.14.0,
0.13.3, 0.13.2, 0.13.1, 0.13.0,
0.12.2, 0.12.1, 0.12.0,
0.11.2, 0.11.1, 0.11.0,
0.10.0

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

Changelog

Best Zopfli parameters so far:
Size Improvement Parameters Found
41528 bytes -3 bytes zopfli --i1000000 --mls32 --bsr18 --lazy --ohh May 23, 2016 @ 20:22
41531 bytes -4 bytes zopfli --i100000 --mls32 --bsr18 --lazy --ohh May 21, 2016 @ 14:26
41535 bytes -8 bytes zopfli --i10000 --mls32 --bsr18 --lazy --ohh May 21, 2016 @ 13:19
41543 bytes -21 bytes zopfli --i1000 --mls32 --bsr18 --lazy --ohh May 21, 2016 @ 13:12
41564 bytes zopfli --i100 --mls32 --bsr18 --lazy --ohh May 21, 2016 @ 12:55

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

Most recent activity on November 22, 2016 @ 16:40.

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, 100,000 or 1,000,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
41743 41746 41744 41591 41744 41709 41745 41744 41744 41741 41739 41747 41752 41756 41763
41648 41649 41647 41565 41662 41645 41663 41663 41652 41646 41647 41738 41748 41749 41660
41746 41741 41742 41740 41651 41646 41738 41655 41738 41745 41744 41746 41758 41757 41564
41569 41644 41638 41643 41634 41647 41636 41631 41645 41637 41636 41737 41751 41749 41751
41559 41563 41544 41545 41556 41563 41558 41555 41556 41552 41557 41741 41749 41752 41575
41557 41645 41642 41557 41644 41645 41641 41634 41644 41636 41641 41738 41750 41747 41651
41643 41641 41643 41643 41636 41648 41641 41633 41639 41640 41640 41738 41750 41749 41746
41558 41552 41545 41536 41558 41554 41556 41561 41641 41556 41557 41738 41751 41753 41651
41557 41560 41638 41649 41558 41557 41558 41554 41556 41558 41556 41742 41750 41750 41571
41643 41647 41644 41644 41635 41639 41635 41632 41639 41741 41635 41738 41748 41749 41574
41557 41637 41639 41541 41640 41646 41637 41645 41637 41638 41557 41741 41750 41750 41659
41558 41562 41642 41542 41557 41547 41556 41557 41641 41552 41555 41737 41751 41753 41571
41563 41565 41558 41542 41555 41644 41557 41555 41558 41554 41556 41742 41751 41751 41655
41560 41572 41559 41537 41558 41563 41557 41570 41556 41556 41558 41742 41746 41755 41572
41567 41563 41554 41564 41528 41557 41557 41559 41555 41557 41557 41738 41750 41752 41572
41642 41643 41640 41635 41633 41640 41635 41631 41635 41556 41638 41742 41751 41753 41652
41563 41565 41641 41642 41566 41544 41639 41633 41635 41639 41635 41738 41748 41748 41573
41557 41565 41543 41545 41566 41548 41560 41553 41553 41555 41559 41741 41751 41752 41650
41562 41569 41543 41543 41555 41564 41638 41556 41557 41551 41556 41738 41751 41748 41583
41563 41566 41642 41534 41534 41564 41555 41555 41555 41554 41638 41741 41748 41751 41566
41643 41648 41648 41636 41638 41563 41557 41563 41556 41558 41556 41737 41747 41750 41570
41565 41565 41561 41541 41555 41560 41557 41554 41559 41638 41638 41742 41748 41748 41576
41565 41565 41556 41541 41560 41551 41564 41551 41552 41550 41557 41742 41748 41749 41571

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 41564 bytes 100%
1,000 41543 bytes -21 bytes 100%
10,000 41535 bytes -8 bytes 100%
100,000 41531 bytes -4 bytes 1.45%
1,000,000 41528 bytes -3 bytes 0.29%
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
41836 bytes +308 bytes (+0.74%) +133 bytes
41836 bytes +308 bytes (+0.74%) +133 bytes
41837 bytes +309 bytes (+0.74%) +134 bytes
41766 bytes +238 bytes (+0.57%) +63 bytes
41725 bytes +197 bytes (+0.47%) +22 bytes
41740 bytes +212 bytes (+0.51%) +37 bytes
41721 bytes +193 bytes (+0.46%) +18 bytes
41703 bytes +175 bytes (+0.42%)
41728 bytes +200 bytes (+0.48%) +25 bytes

Non-DEFLATE Algorithms

Archivers based on completely different compression algorithms often produce superior results.
Unfortunately, browsers only support gzip compression at the moment.
Algorithm Program Parameters Size Compared To Best Zopfli
ZPAQ (Wikipedia) zpaq zpaq -method 69 30342 bytes -11186 bytes (-26.94%)
RAR (proprietary) RAR rar a -m5 -md64m -mc63:128t -mt1 32909 bytes -8619 bytes (-20.75%)
PPMd (Wikipedia) 7zip 7za a -mx=9 -m0=ppmd 35083 bytes -6445 bytes (-15.52%)
Brotli (Wikipedia) brotli brotli -q 11 36642 bytes -4886 bytes (-11.77%)
Burrows-Wheeler transform (Wikipedia) bzip2 bzip2 -9 37186 bytes -4342 bytes (-10.46%)
LZMA2 (Wikipedia) xz xz -9 37804 bytes -3724 bytes (-8.97%)
ZSTD (Wikipedia) zstd zstd -19 39469 bytes -2059 bytes (-4.96%)

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