Updated to 5.2

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 All notable changes to this project will be documented in this file.
 
+## [5.2] - 2020-12-17
+- Added: Common Apps: Download useful apps quickly at once
+- Improved: Disable Telemetry Services
+
 ## [5.1] - 2020-12-11
 - Some UI warnings
 

Optimizer/AppInfo.cs

@@ -0,0 +1,16 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Optimizer
+{
+    public class AppInfo
+    {
+        public string Title { get; set; }
+        public Uri Link64 { get; set; }
+        public Uri Link { get; set; }
+        public string Tag { get; set; }
+    }
+}

Optimizer/AppLinks.cs

@@ -0,0 +1,278 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Optimizer
+{
+    public class AppLinks
+    {
+        public AppInfo Chromium = new AppInfo();
+        public AppInfo Firefox = new AppInfo();
+        public AppInfo Vivaldi = new AppInfo();
+        public AppInfo Chrome = new AppInfo();
+        public AppInfo Opera = new AppInfo();
+
+        public AppInfo VLC = new AppInfo();
+        public AppInfo PotPlayer = new AppInfo();
+        public AppInfo Foobar2000 = new AppInfo();
+        public AppInfo BSPlayer = new AppInfo();
+        public AppInfo IrfanView = new AppInfo();
+        public AppInfo PhotoFiltre = new AppInfo();
+
+        public AppInfo SevenZip = new AppInfo();
+        public AppInfo PeaZip = new AppInfo();
+        public AppInfo WinRAR = new AppInfo();
+
+        public AppInfo SumatraPDF = new AppInfo();
+        public AppInfo Foxit = new AppInfo();
+        public AppInfo AdobeReader = new AppInfo();
+
+        public AppInfo Discord = new AppInfo();
+        public AppInfo Skype = new AppInfo();
+        public AppInfo Viber = new AppInfo();
+        public AppInfo Thunderbird = new AppInfo();
+
+        public AppInfo NotepadPP = new AppInfo();
+        public AppInfo SublimeText = new AppInfo();
+        public AppInfo VSCode = new AppInfo();
+        public AppInfo Atom = new AppInfo();
+        public AppInfo VS = new AppInfo();
+        public AppInfo SublimeMerge = new AppInfo();
+
+        public AppInfo QBitTorrent = new AppInfo();
+        public AppInfo Deluge = new AppInfo();
+        public AppInfo UTorrent = new AppInfo();
+        public AppInfo BitTorrent = new AppInfo();
+
+        public AppInfo Putty = new AppInfo();
+        public AppInfo FileZilla = new AppInfo();
+        public AppInfo GitHub = new AppInfo();
+        public AppInfo NodeJS = new AppInfo();
+        public AppInfo XAMPP = new AppInfo();
+        public AppInfo Postman = new AppInfo();
+
+        public List<AppInfo> Apps = new List<AppInfo>();
+
+        public AppLinks()
+        {
+            // BROWSERS
+            Chromium.Title = "Chromium";
+            Chromium.Link64 = new Uri("https://github.com/Hibbiki/chromium-win64/releases/download/v87.0.4280.88-r812852/mini_installer.sync.exe");
+            Chromium.Link = new Uri("https://github.com/Hibbiki/chromium-win32/releases/download/v87.0.4280.88-r812852/mini_installer.sync.exe");
+            Chromium.Tag = "cChromium";
+
+            Firefox.Title = "Mozilla Firefox";
+            Firefox.Link64 = new Uri("https://ftp.mozilla.org/pub/firefox/releases/84.0/win64/en-US/Firefox%20Setup%2084.0.exe");
+            Firefox.Link = new Uri("https://ftp.mozilla.org/pub/firefox/releases/84.0/win32/en-US/Firefox%20Setup%2084.0.exe");
+            Firefox.Tag = "cFirefox";
+
+            Vivaldi.Title = "Vivaldi";
+            Vivaldi.Link64 = new Uri("https://downloads.vivaldi.com/stable/Vivaldi.3.5.2115.81.x64.exe");
+            Vivaldi.Link = new Uri("https://downloads.vivaldi.com/stable/Vivaldi.3.5.2115.81.exe");
+            Vivaldi.Tag = "cVivaldi";
+
+            Chrome.Title = "Google Chrome";
+            Chrome.Link64 = new Uri("https://dl.google.com/tag/s/appguid%3D%7B8A69D345-D564-463C-AFF1-A69D9E530F96%7D%26iid%3D%7BFD62DDBC-14C6-20BD-706F-C7744738E422%7D%26lang%3Den%26browser%3D3%26usagestats%3D0%26appname%3DGoogle%2520Chrome%26needsadmin%3Dprefers%26ap%3Dx64-stable-statsdef_1%26installdataindex%3Dempty/chrome/install/ChromeStandaloneSetup64.exe");
+            Chrome.Link = new Uri("https://dl.google.com/tag/s/appguid%3D%7B8A69D345-D564-463C-AFF1-A69D9E530F96%7D%26iid%3D%7BFD62DDBC-14C6-20BD-706F-C7744738E422%7D%26lang%3Den%26browser%3D3%26usagestats%3D0%26appname%3DGoogle%2520Chrome%26needsadmin%3Dprefers%26ap%3Dstable-arch_x86-statsdef_1%26installdataindex%3Dempty/chrome/install/ChromeStandaloneSetup.exe");
+            Chrome.Tag = "cChrome";
+
+            Opera.Title = "Opera";
+            Opera.Link64 = new Uri("https://www.opera.com/download/get/?partner=www&opsys=Windows&arch=x64");
+            Opera.Link = new Uri("https://www.opera.com/download/get/?partner=www&opsys=Windows");
+            Opera.Tag = "cOpera";
+
+            // ARCHIVING
+            SevenZip.Title = "7-Zip";
+            SevenZip.Link64 = new Uri("https://www.7-zip.org/a/7z1900-x64.exe");
+            SevenZip.Link = new Uri("https://www.7-zip.org/a/7z1900.exe");
+            SevenZip.Tag = "c7zip";
+
+            PeaZip.Title = "PeaZip";
+            PeaZip.Link64 = new Uri("https://github.com/peazip/PeaZip/releases/download/7.6.0/peazip-7.6.0.WIN64.exe");
+            PeaZip.Link = new Uri("https://github.com/peazip/PeaZip/releases/download/7.6.0/peazip-7.6.0.WINDOWS.exe");
+            PeaZip.Tag = "cPeaZip";
+
+            WinRAR.Title = "WinRAR";
+            WinRAR.Link64 = new Uri("https://www.win-rar.com/fileadmin/winrar-versions/winrar/winrar-x64-600.exe");
+            WinRAR.Link = new Uri("https://www.win-rar.com/fileadmin/winrar-versions/winrar/wrar600.exe");
+            WinRAR.Tag = "cWinRar";
+
+            // MEDIA PLAYERS
+            VLC.Title = "VLC Media Player";
+            VLC.Link64 = new Uri("https://get.videolan.org/vlc/3.0.11/win64/vlc-3.0.11-win64.exe");
+            VLC.Link = new Uri("https://get.videolan.org/vlc/3.0.11/win32/vlc-3.0.11-win32.exe");
+            VLC.Tag = "cVLC";
+
+            PotPlayer.Title = "PotPlayer";
+            PotPlayer.Link64 = new Uri("https://t1.daumcdn.net/potplayer/PotPlayer/Version/Latest/PotPlayerSetup64.exe");
+            PotPlayer.Link = new Uri("https://t1.daumcdn.net/potplayer/PotPlayer/Version/Latest/PotPlayerSetup.exe");
+            PotPlayer.Tag = "cPot";
+
+            Foobar2000.Title = "Foobar2000";
+            Foobar2000.Link = new Uri("https://www.foobar2000.org/files/eb9257c7785d4241dc9137edb3d4bfde/foobar2000_v1.6.2.exe");
+            Foobar2000.Tag = "cFoobar";
+
+            BSPlayer.Title = "BS.Player";
+            BSPlayer.Link = new Uri("http://download11.bsplayer.com/download/file/mirror1/bsplayer276.setup.exe");
+            BSPlayer.Tag = "cBS";
+
+            IrfanView.Title = "IrfanView";
+            IrfanView.Link = new Uri("http://download.betanews.com/download/967963863-1/iview456_setup.exe");
+            IrfanView.Tag = "cIrfan";
+
+            PhotoFiltre.Title = "PhotoFiltre";
+            PhotoFiltre.Link = new Uri("http://static.infomaniak.ch/photofiltre/utils/pf7/pf7-setup-en-7.2.1.exe");
+            PhotoFiltre.Tag = "cPhotoFiltre";
+
+            // E-READERS
+            SumatraPDF.Title = "SumatraPDF";
+            SumatraPDF.Link64 = new Uri("https://www.sumatrapdfreader.org/dl2/SumatraPDF-3.2-64-install.exe");
+            SumatraPDF.Link = new Uri("https://www.sumatrapdfreader.org/dl2/SumatraPDF-3.2-install.exe");
+            SumatraPDF.Tag = "cSumatra";
+
+            Foxit.Title = "Foxit Reader";
+            Foxit.Link = new Uri("https://cdn01.foxitsoftware.com/product/reader/desktop/win/10.1.1/FoxitReader1011_enu_Setup_Prom.exe");
+            Foxit.Tag = "cFoxit";
+
+            AdobeReader.Title = "Adobe Reader";
+            AdobeReader.Link = new Uri("https://ardownload2.adobe.com/pub/adobe/reader/win/AcrobatDC/2001320074/AcroRdrDC2001320074_en_US.exe");
+            AdobeReader.Tag = "cAdobeReader";
+
+            // COMMUNICATION
+            Discord.Title = "Discord";
+            Discord.Link = new Uri("https://dl.discordapp.net/apps/win/0.0.309/DiscordSetup.exe");
+            Discord.Tag = "cDiscord";
+
+            Skype.Title = "Skype";
+            Skype.Link = new Uri("https://download.skype.com/s4l/download/win/Skype-8.67.0.96.exe");
+            Skype.Tag = "cSkype";
+
+            Viber.Title = "Viber";
+            Viber.Link = new Uri("https://download.cdn.viber.com/desktop/windows/ViberSetup.exe");
+            Viber.Tag = "cViber";
+
+            Thunderbird.Title = "Thunderbird";
+            Thunderbird.Link = new Uri("https://download-installer.cdn.mozilla.net/pub/thunderbird/releases/78.6.0/win32/en-US/Thunderbird%20Setup%2078.6.0.exe");
+            Thunderbird.Tag = "cThunderbird";
+
+            // TEXT EDITORS & IDEs
+            NotepadPP.Title = "Notepad++";
+            NotepadPP.Link = new Uri("https://github.com/notepad-plus-plus/notepad-plus-plus/releases/download/v7.9.1/npp.7.9.1.Installer.exe");
+            NotepadPP.Tag = "cNPP";
+
+            SublimeText.Title = "Sublime Text";
+            SublimeText.Link64 = new Uri("https://download.sublimetext.com/Sublime%20Text%20Build%203211%20x64%20Setup.exe");
+            SublimeText.Link = new Uri("https://download.sublimetext.com/Sublime%20Text%20Build%203211%20Setup.exe");
+            SublimeText.Tag = "cSublimeText";
+
+            VSCode.Title = "Visual Studio Code";
+            VSCode.Link64 = new Uri("https://az764295.vo.msecnd.net/stable/940b5f4bb5fa47866a54529ed759d95d09ee80be/VSCodeUserSetup-x64-1.52.0.exe");
+            VSCode.Link = new Uri("https://az764295.vo.msecnd.net/stable/940b5f4bb5fa47866a54529ed759d95d09ee80be/VSCodeUserSetup-ia32-1.52.0.exe");
+            VSCode.Tag = "cVSCode";
+
+            Atom.Title = "Atom";
+            Atom.Link64 = new Uri("https://github.com/atom/atom/releases/download/v1.53.0/AtomSetup-x64.exe");
+            Atom.Link = new Uri("https://github.com/atom/atom/releases/download/v1.53.0/AtomSetup.exe");
+            Atom.Tag = "cAtom";
+
+            VS.Title = "Visual Studio";
+            VS.Link = new Uri("https://download.visualstudio.microsoft.com/download/pr/9b3476ff-6d0a-4ff8-956d-270147f21cd4/76e39c746d9e2fc3eadd003b5b11440bcf926f3948fb2df14d5938a1a8b2b32f/vs_Community.exe");
+            VS.Tag = "cVS";
+
+            SublimeMerge.Title = "Sublime Merge";
+            SublimeMerge.Link64 = new Uri("https://download.sublimetext.com/sublime_merge_build_2039_x64_setup.exe");
+            SublimeMerge.Tag = "cSublimeMerge";
+
+            // TORRENTING
+            QBitTorrent.Title = "qBitTorrent";
+            QBitTorrent.Link64 = new Uri("https://vorboss.dl.sourceforge.net/project/qbittorrent/qbittorrent-win32/qbittorrent-4.3.1/qbittorrent_4.3.1_x64_setup.exe");
+            QBitTorrent.Link = new Uri("https://kumisystems.dl.sourceforge.net/project/qbittorrent/qbittorrent-win32/qbittorrent-4.3.1/qbittorrent_4.3.1_setup.exe");
+            QBitTorrent.Tag = "cQB";
+
+            Deluge.Title = "Deluge";
+            Deluge.Link = new Uri("https://ftp.osuosl.org/pub/deluge/windows/deluge-1.3.15-win32-py2.7.exe");
+            Deluge.Tag = "cDeluge";
+
+            UTorrent.Title = "uTorrent";
+            UTorrent.Link = new Uri("https://download-hr.utorrent.com/track/stable/endpoint/utorrent/os/windows");
+            UTorrent.Tag = "cUT";
+
+            BitTorrent.Title = "BitTorrent";
+            BitTorrent.Link = new Uri("https://download-new.utorrent.com/endpoint/bittorrent/os/windows/track/stable/");
+            BitTorrent.Tag = "cBT";
+
+            // CODING TOOLS
+            Putty.Title = "Putty";
+            Putty.Link64 = new Uri("https://the.earth.li/~sgtatham/putty/latest/w64/putty-64bit-0.74-installer.msi");
+            Putty.Link = new Uri("https://the.earth.li/~sgtatham/putty/latest/w32/putty-0.74-installer.msi");
+            Putty.Tag = "cPutty";
+
+            FileZilla.Title = "FileZilla";
+            FileZilla.Link64 = new Uri("https://download.filezilla-project.org/client/FileZilla_3.51.0_win64-setup.exe");
+            FileZilla.Link = new Uri("https://download.filezilla-project.org/client/FileZilla_3.51.0_win32-setup.exe");
+            FileZilla.Tag = "cFileZilla";
+
+            GitHub.Title = "GitHub";
+            GitHub.Link = new Uri("https://desktop.githubusercontent.com/releases/2.6.1-afb56263/GitHubDesktopSetup.exe");
+            GitHub.Tag = "cGitHub";
+
+            NodeJS.Title = "NodeJS";
+            NodeJS.Link = new Uri("https://nodejs.org/dist/v14.15.2/node-v14.15.2-x64.msi");
+            NodeJS.Tag = "cNode";
+
+            XAMPP.Title = "XAMPP";
+            XAMPP.Link64 = new Uri("https://downloadsapachefriends.global.ssl.fastly.net/8.0.0/xampp-windows-x64-8.0.0-2-VS16-installer.exe");
+            XAMPP.Tag = "cXAMPP";
+
+            Postman.Title = "Postman";
+            Postman.Link64 = new Uri("https://dl.pstmn.io/download/latest/win64");
+            Postman.Link = new Uri("https://dl.pstmn.io/download/latest/win32");
+            Postman.Tag = "cPostman";
+
+            CreateList();
+        }
+
+        private void CreateList()
+        {
+            Apps.Add(Chromium);
+            Apps.Add(Firefox);
+            Apps.Add(Vivaldi);
+            Apps.Add(Chrome);
+            Apps.Add(Opera);
+            Apps.Add(SevenZip);
+            Apps.Add(PeaZip);
+            Apps.Add(WinRAR);
+            Apps.Add(VLC);
+            Apps.Add(PotPlayer);
+            Apps.Add(Foobar2000);
+            Apps.Add(BSPlayer);
+            Apps.Add(IrfanView);
+            Apps.Add(PhotoFiltre);
+            Apps.Add(SumatraPDF);
+            Apps.Add(Foxit);
+            Apps.Add(AdobeReader);
+            Apps.Add(Discord);
+            Apps.Add(Skype);
+            Apps.Add(Viber);
+            Apps.Add(Thunderbird);
+            Apps.Add(QBitTorrent);
+            Apps.Add(Deluge);
+            Apps.Add(UTorrent);
+            Apps.Add(BitTorrent);
+            Apps.Add(NotepadPP);
+            Apps.Add(SublimeMerge);
+            Apps.Add(VSCode);
+            Apps.Add(Atom);
+            Apps.Add(VS);
+            Apps.Add(SublimeText);
+            Apps.Add(Putty);
+            Apps.Add(FileZilla);
+            Apps.Add(GitHub);
+            Apps.Add(NodeJS);
+            Apps.Add(XAMPP);
+            Apps.Add(Postman);
+        }
+    }
+}

Optimizer/ByteSize/BinaryByteSize.cs

@@ -0,0 +1,86 @@
+using System;
+using System.Globalization;
+
+namespace Optimizer
+{
+    public partial struct ByteSize
+    {
+        public const long BytesInKibiByte = 1_024;
+        public const long BytesInMebiByte = 1_048_576;
+        public const long BytesInGibiByte = 1_073_741_824;
+        public const long BytesInTebiByte = 1_099_511_627_776;
+        public const long BytesInPebiByte = 1_125_899_906_842_624;
+
+        public const string KibiByteSymbol = "KiB";
+        public const string MebiByteSymbol = "MiB";
+        public const string GibiByteSymbol = "GiB";
+        public const string TebiByteSymbol = "TiB";
+        public const string PebiByteSymbol = "PiB";
+
+        public double KibiBytes => Bytes / BytesInKibiByte;
+        public double MebiBytes => Bytes / BytesInMebiByte;
+        public double GibiBytes => Bytes / BytesInGibiByte;
+        public double TebiBytes => Bytes / BytesInTebiByte;
+        public double PebiBytes => Bytes / BytesInPebiByte;
+
+        public static ByteSize FromKibiBytes(double value)
+        {
+            return new ByteSize(value * BytesInKibiByte);
+        }
+
+        public static ByteSize FromMebiBytes(double value)
+        {
+            return new ByteSize(value * BytesInMebiByte);
+        }
+
+        public static ByteSize FromGibiBytes(double value)
+        {
+            return new ByteSize(value * BytesInGibiByte);
+        }
+
+        public static ByteSize FromTebiBytes(double value)
+        {
+            return new ByteSize(value * BytesInTebiByte);
+        }
+
+        public static ByteSize FromPebiBytes(double value)
+        {
+            return new ByteSize(value * BytesInPebiByte);
+        }
+
+        public ByteSize AddKibiBytes(double value)
+        {
+            return this + ByteSize.FromKibiBytes(value);
+        }
+
+        public ByteSize AddMebiBytes(double value)
+        {
+            return this + ByteSize.FromMebiBytes(value);
+        }
+
+        public ByteSize AddGibiBytes(double value)
+        {
+            return this + ByteSize.FromGibiBytes(value);
+        }
+
+        public ByteSize AddTebiBytes(double value)
+        {
+            return this + ByteSize.FromTebiBytes(value);
+        }
+
+        public ByteSize AddPebiBytes(double value)
+        {
+            return this + ByteSize.FromPebiBytes(value);
+        }
+
+        public string ToBinaryString()
+        {
+            return this.ToString("0.##", CultureInfo.CurrentCulture, useBinaryByte: true);
+        }
+
+        public string ToBinaryString(IFormatProvider formatProvider)
+        {
+            return this.ToString("0.##", formatProvider, useBinaryByte: true);
+        }
+    }
+}

Optimizer/ByteSize/ByteSize.cs

@@ -0,0 +1,454 @@
+using System;
+using System.Globalization;
+
+namespace Optimizer
+{
+    /// <summary>
+    /// Represents a byte size value with support for decimal (KiloByte) and
+    /// binary values (KibiByte).
+    /// </summary>
+    public partial struct ByteSize : IComparable<ByteSize>, IEquatable<ByteSize>
+    {
+        public static readonly ByteSize MinValue = ByteSize.FromBits(long.MinValue);
+        public static readonly ByteSize MaxValue = ByteSize.FromBits(long.MaxValue);
+        public const long BitsInByte = 8;
+        public const string BitSymbol = "b";
+        public const string ByteSymbol = "B";
+        public long Bits { get; private set; }
+        public double Bytes { get; private set; }
+
+        public string LargestWholeNumberBinarySymbol
+        {
+            get
+            {
+                // Absolute value is used to deal with negative values
+                if (Math.Abs(this.PebiBytes) >= 1)
+                    return PebiByteSymbol;
+
+                if (Math.Abs(this.TebiBytes) >= 1)
+                    return TebiByteSymbol;
+
+                if (Math.Abs(this.GibiBytes) >= 1)
+                    return GibiByteSymbol;
+
+                if (Math.Abs(this.MebiBytes) >= 1)
+                    return MebiByteSymbol;
+
+                if (Math.Abs(this.KibiBytes) >= 1)
+                    return KibiByteSymbol;
+
+                if (Math.Abs(this.Bytes) >= 1)
+                    return ByteSymbol;
+
+                return BitSymbol;
+            }
+        }
+
+        public string LargestWholeNumberDecimalSymbol
+        {
+            get
+            {
+                // Absolute value is used to deal with negative values
+                if (Math.Abs(this.PetaBytes) >= 1)
+                    return PetaByteSymbol;
+
+                if (Math.Abs(this.TeraBytes) >= 1)
+                    return TeraByteSymbol;
+
+                if (Math.Abs(this.GigaBytes) >= 1)
+                    return GigaByteSymbol;
+
+                if (Math.Abs(this.MegaBytes) >= 1)
+                    return MegaByteSymbol;
+
+                if (Math.Abs(this.KiloBytes) >= 1)
+                    return KiloByteSymbol;
+
+                if (Math.Abs(this.Bytes) >= 1)
+                    return ByteSymbol;
+
+                return BitSymbol;
+            }
+        }
+
+        public double LargestWholeNumberBinaryValue
+        {
+            get
+            {
+                // Absolute value is used to deal with negative values
+                if (Math.Abs(this.PebiBytes) >= 1)
+                    return this.PebiBytes;
+
+                if (Math.Abs(this.TebiBytes) >= 1)
+                    return this.TebiBytes;
+
+                if (Math.Abs(this.GibiBytes) >= 1)
+                    return this.GibiBytes;
+
+                if (Math.Abs(this.MebiBytes) >= 1)
+                    return this.MebiBytes;
+
+                if (Math.Abs(this.KibiBytes) >= 1)
+                    return this.KibiBytes;
+
+                if (Math.Abs(this.Bytes) >= 1)
+                    return this.Bytes;
+
+                return this.Bits;
+            }
+        }
+
+        public double LargestWholeNumberDecimalValue
+        {
+            get
+            {
+                // Absolute value is used to deal with negative values
+                if (Math.Abs(this.PetaBytes) >= 1)
+                    return this.PetaBytes;
+
+                if (Math.Abs(this.TeraBytes) >= 1)
+                    return this.TeraBytes;
+
+                if (Math.Abs(this.GigaBytes) >= 1)
+                    return this.GigaBytes;
+
+                if (Math.Abs(this.MegaBytes) >= 1)
+                    return this.MegaBytes;
+
+                if (Math.Abs(this.KiloBytes) >= 1)
+                    return this.KiloBytes;
+
+                if (Math.Abs(this.Bytes) >= 1)
+                    return this.Bytes;
+
+                return this.Bits;
+            }
+        }
+
+        public ByteSize(long bits)
+            : this()
+        {
+            Bits = bits;
+
+            Bytes = bits / BitsInByte;
+        }
+
+        public ByteSize(double bytes)
+            : this()
+        {
+            // Get ceiling because bits are whole units
+            Bits = (long)Math.Ceiling(bytes * BitsInByte);
+
+            Bytes = bytes;
+        }
+
+        public static ByteSize FromBits(long value)
+        {
+            return new ByteSize(value);
+        }
+
+        public static ByteSize FromBytes(double value)
+        {
+            return new ByteSize(value);
+        }
+
+        /// <summary>
+        /// Converts the value of the current object to a string.
+        /// The prefix symbol (bit, byte, kilo, mebi, gibi, tebi) used is the
+        /// largest prefix such that the corresponding value is greater than or
+        /// equal to one.
+        /// </summary>
+        public override string ToString()
+        {
+            return this.ToString("0.##", CultureInfo.CurrentCulture);
+        }
+
+        public string ToString(string format)
+        {
+            return this.ToString(format, CultureInfo.CurrentCulture);
+        }
+
+        public string ToString(string format, IFormatProvider provider, bool useBinaryByte = false)
+        {
+            if (!format.Contains("#") && !format.Contains("0"))
+                format = "0.## " + format;
+
+            if (provider == null) provider = CultureInfo.CurrentCulture;
+
+            Func<string, bool> has = s => format.IndexOf(s, StringComparison.CurrentCultureIgnoreCase) != -1;
+            Func<double, string> output = n => n.ToString(format, provider);
+
+            // Binary
+            if (has("PiB"))
+                return output(this.PebiBytes);
+            if (has("TiB"))
+                return output(this.TebiBytes);
+            if (has("GiB"))
+                return output(this.GibiBytes);
+            if (has("MiB"))
+                return output(this.MebiBytes);
+            if (has("KiB"))
+                return output(this.KibiBytes);
+
+            // Decimal
+            if (has("PB"))
+                return output(this.PetaBytes);
+            if (has("TB"))
+                return output(this.TeraBytes);
+            if (has("GB"))
+                return output(this.GigaBytes);
+            if (has("MB"))
+                return output(this.MegaBytes);
+            if (has("KB"))
+                return output(this.KiloBytes);
+
+            // Byte and Bit symbol must be case-sensitive
+            if (format.IndexOf(ByteSize.ByteSymbol) != -1)
+                return output(this.Bytes);
+
+            if (format.IndexOf(ByteSize.BitSymbol) != -1)
+                return output(this.Bits);
+
+            if (useBinaryByte)
+            {
+                return string.Format("{0} {1}", this.LargestWholeNumberBinaryValue.ToString(format, provider), this.LargestWholeNumberBinarySymbol);
+            }
+            else
+            {
+                return string.Format("{0} {1}", this.LargestWholeNumberDecimalValue.ToString(format, provider), this.LargestWholeNumberDecimalSymbol);
+            }
+        }
+
+        public override bool Equals(object value)
+        {
+            if (value == null)
+                return false;
+
+            ByteSize other;
+            if (value is ByteSize)
+                other = (ByteSize)value;
+            else
+                return false;
+
+            return Equals(other);
+        }
+
+        public bool Equals(ByteSize value)
+        {
+            return this.Bits == value.Bits;
+        }
+
+        public override int GetHashCode()
+        {
+            return this.Bits.GetHashCode();
+        }
+
+        public int CompareTo(ByteSize other)
+        {
+            return this.Bits.CompareTo(other.Bits);
+        }
+
+        public ByteSize Add(ByteSize bs)
+        {
+            return new ByteSize(this.Bytes + bs.Bytes);
+        }
+
+        public ByteSize AddBits(long value)
+        {
+            return this + FromBits(value);
+        }
+
+        public ByteSize AddBytes(double value)
+        {
+            return this + ByteSize.FromBytes(value);
+        }
+
+        public ByteSize Subtract(ByteSize bs)
+        {
+            return new ByteSize(this.Bytes - bs.Bytes);
+        }
+
+        public static ByteSize operator +(ByteSize b1, ByteSize b2)
+        {
+            return new ByteSize(b1.Bytes + b2.Bytes);
+        }
+
+        public static ByteSize operator ++(ByteSize b)
+        {
+            return new ByteSize(b.Bytes + 1);
+        }
+
+        public static ByteSize operator -(ByteSize b)
+        {
+            return new ByteSize(-b.Bytes);
+        }
+
+        public static ByteSize operator -(ByteSize b1, ByteSize b2)
+        {
+            return new ByteSize(b1.Bytes - b2.Bytes);
+        }
+
+        public static ByteSize operator --(ByteSize b)
+        {
+            return new ByteSize(b.Bytes - 1);
+        }
+
+        public static bool operator ==(ByteSize b1, ByteSize b2)
+        {
+            return b1.Bits == b2.Bits;
+        }
+
+        public static bool operator !=(ByteSize b1, ByteSize b2)
+        {
+            return b1.Bits != b2.Bits;
+        }
+
+        public static bool operator <(ByteSize b1, ByteSize b2)
+        {
+            return b1.Bits < b2.Bits;
+        }
+
+        public static bool operator <=(ByteSize b1, ByteSize b2)
+        {
+            return b1.Bits <= b2.Bits;
+        }
+
+        public static bool operator >(ByteSize b1, ByteSize b2)
+        {
+            return b1.Bits > b2.Bits;
+        }
+
+        public static bool operator >=(ByteSize b1, ByteSize b2)
+        {
+            return b1.Bits >= b2.Bits;
+        }
+
+        public static ByteSize Parse(string s)
+        {
+            return Parse(s, NumberFormatInfo.CurrentInfo);
+        }
+        public static ByteSize Parse(string s, IFormatProvider formatProvider)
+        {
+            return Parse(s, NumberStyles.Float | NumberStyles.AllowThousands, formatProvider);
+        }
+
+        public static ByteSize Parse(string s, NumberStyles numberStyles, IFormatProvider formatProvider)
+        {
+
+            // Arg checking
+            if (string.IsNullOrWhiteSpace(s))
+                throw new ArgumentNullException("s", "String is null or whitespace");
+
+            // Get the index of the first non-digit character
+            s = s.TrimStart(); // Protect against leading spaces
+
+            var num = 0;
+            var found = false;
+
+            var numberFormatInfo = NumberFormatInfo.GetInstance(formatProvider);
+            var decimalSeparator = Convert.ToChar(numberFormatInfo.NumberDecimalSeparator);
+            var groupSeparator = Convert.ToChar(numberFormatInfo.NumberGroupSeparator);
+
+            // Pick first non-digit number
+            for (num = 0; num < s.Length; num++)
+                if (!(char.IsDigit(s[num]) || s[num] == decimalSeparator || s[num] == groupSeparator))
+                {
+                    found = true;
+                    break;
+                }
+
+            if (found == false)
+                throw new FormatException($"No byte indicator found in value '{s}'.");
+
+            int lastNumber = num;
+
+            // Cut the input string in half
+            string numberPart = s.Substring(0, lastNumber).Trim();
+            string sizePart = s.Substring(lastNumber, s.Length - lastNumber).Trim();
+
+            // Get the numeric part
+            double number;
+            if (!double.TryParse(numberPart, numberStyles, formatProvider, out number))
+                throw new FormatException($"No number found in value '{s}'.");
+
+            // Get the magnitude part
+            switch (sizePart)
+            {
+                case "b":
+                    if (number % 1 != 0) // Can't have partial bits
+                        throw new FormatException($"Can't have partial bits for value '{s}'.");
+
+                    return FromBits((long)number);
+
+                case "B":
+                    return FromBytes(number);
+            }
+
+            switch (sizePart.ToLowerInvariant())
+            {
+                // Binary
+                case "kib":
+                    return FromKibiBytes(number);
+
+                case "mib":
+                    return FromMebiBytes(number);
+
+                case "gib":
+                    return FromGibiBytes(number);
+
+                case "tib":
+                    return FromTebiBytes(number);
+
+                case "pib":
+                    return FromPebiBytes(number);
+
+                // Decimal
+                case "kb":
+                    return FromKiloBytes(number);
+
+                case "mb":
+                    return FromMegaBytes(number);
+
+                case "gb":
+                    return FromGigaBytes(number);
+
+                case "tb":
+                    return FromTeraBytes(number);
+
+                case "pb":
+                    return FromPetaBytes(number);
+
+                default:
+                    throw new FormatException($"Bytes of magnitude '{sizePart}' is not supported.");
+            }
+        }
+
+        public static bool TryParse(string s, out ByteSize result)
+        {
+            try
+            {
+                result = Parse(s);
+                return true;
+            }
+            catch
+            {
+                result = new ByteSize();
+                return false;
+            }
+        }
+
+        public static bool TryParse(string s, NumberStyles numberStyles, IFormatProvider formatProvider, out ByteSize result)
+        {
+            try
+            {
+                result = Parse(s, numberStyles, formatProvider);
+                return true;
+            }
+            catch
+            {
+                result = new ByteSize();
+                return false;
+            }
+        }
+    }
+}

Optimizer/ByteSize/DecimalByteSize.cs

@@ -0,0 +1,76 @@
+using System;
+using System.Globalization;
+
+namespace Optimizer
+{
+    public partial struct ByteSize
+    {
+        public const long BytesInKiloByte = 1_000;
+        public const long BytesInMegaByte = 1_000_000;
+        public const long BytesInGigaByte = 1_000_000_000;
+        public const long BytesInTeraByte = 1_000_000_000_000;
+        public const long BytesInPetaByte = 1_000_000_000_000_000;
+
+        public const string KiloByteSymbol = "KB";
+        public const string MegaByteSymbol = "MB";
+        public const string GigaByteSymbol = "GB";
+        public const string TeraByteSymbol = "TB";
+        public const string PetaByteSymbol = "PB";
+
+        public double KiloBytes => Bytes / BytesInKiloByte;
+        public double MegaBytes => Bytes / BytesInMegaByte;
+        public double GigaBytes => Bytes / BytesInGigaByte;
+        public double TeraBytes => Bytes / BytesInTeraByte;
+        public double PetaBytes => Bytes / BytesInPetaByte;
+
+        public static ByteSize FromKiloBytes(double value)
+        {
+            return new ByteSize(value * BytesInKiloByte);
+        }
+
+        public static ByteSize FromMegaBytes(double value)
+        {
+            return new ByteSize(value * BytesInMegaByte);
+        }
+
+        public static ByteSize FromGigaBytes(double value)
+        {
+            return new ByteSize(value * BytesInGigaByte);
+        }
+
+        public static ByteSize FromTeraBytes(double value)
+        {
+            return new ByteSize(value * BytesInTeraByte);
+        }
+
+        public static ByteSize FromPetaBytes(double value)
+        {
+            return new ByteSize(value * BytesInPetaByte);
+        }
+
+        public ByteSize AddKiloBytes(double value)
+        {
+            return this + ByteSize.FromKiloBytes(value);
+        }
+
+        public ByteSize AddMegaBytes(double value)
+        {
+            return this + ByteSize.FromMegaBytes(value);
+        }
+
+        public ByteSize AddGigaBytes(double value)
+        {
+            return this + ByteSize.FromGigaBytes(value);
+        }
+
+        public ByteSize AddTeraBytes(double value)
+        {
+            return this + ByteSize.FromTeraBytes(value);
+        }
+
+        public ByteSize AddPetaBytes(double value)
+        {
+            return this + ByteSize.FromPetaBytes(value);
+        }
+    }
+}

Optimizer/InfoForm.Designer.cs

@@ -42,9 +42,10 @@
             this.btnOK.FlatAppearance.MouseOverBackColor = System.Drawing.Color.RoyalBlue;
             this.btnOK.FlatStyle = System.Windows.Forms.FlatStyle.Flat;
             this.btnOK.ForeColor = System.Drawing.Color.White;
-            this.btnOK.Location = new System.Drawing.Point(379, 442);
+            this.btnOK.Location = new System.Drawing.Point(487, 354);
+            this.btnOK.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
             this.btnOK.Name = "btnOK";
-            this.btnOK.Size = new System.Drawing.Size(120, 39);
+            this.btnOK.Size = new System.Drawing.Size(96, 31);
             this.btnOK.TabIndex = 32;
             this.btnOK.Tag = "themeable";
             this.btnOK.Text = "OK";
@@ -57,29 +58,30 @@
             this.txtInfo.BorderStyle = System.Windows.Forms.BorderStyle.None;
             this.txtInfo.Font = new System.Drawing.Font("Segoe UI Semibold", 12F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
             this.txtInfo.ForeColor = System.Drawing.Color.White;
-            this.txtInfo.Location = new System.Drawing.Point(12, 12);
+            this.txtInfo.Location = new System.Drawing.Point(10, 10);
+            this.txtInfo.Margin = new System.Windows.Forms.Padding(2, 2, 2, 2);
             this.txtInfo.Multiline = true;
             this.txtInfo.Name = "txtInfo";
             this.txtInfo.ReadOnly = true;
             this.txtInfo.ScrollBars = System.Windows.Forms.ScrollBars.Vertical;
-            this.txtInfo.Size = new System.Drawing.Size(487, 414);
+            this.txtInfo.Size = new System.Drawing.Size(572, 331);
             this.txtInfo.TabIndex = 33;
             this.txtInfo.Text = "Integrator InfoBox";
             // 
             // InfoForm
             // 
             this.AcceptButton = this.btnOK;
-            this.AutoScaleDimensions = new System.Drawing.SizeF(120F, 120F);
+            this.AutoScaleDimensions = new System.Drawing.SizeF(96F, 96F);
             this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Dpi;
             this.BackColor = System.Drawing.Color.FromArgb(((int)(((byte)(20)))), ((int)(((byte)(20)))), ((int)(((byte)(20)))));
             this.CancelButton = this.btnOK;
-            this.ClientSize = new System.Drawing.Size(511, 493);
+            this.ClientSize = new System.Drawing.Size(593, 394);
             this.Controls.Add(this.txtInfo);
             this.Controls.Add(this.btnOK);
             this.Font = new System.Drawing.Font("Segoe UI Semibold", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(0)));
             this.ForeColor = System.Drawing.Color.White;
             this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle;
-            this.Margin = new System.Windows.Forms.Padding(3, 4, 3, 4);
+            this.Margin = new System.Windows.Forms.Padding(2, 3, 2, 3);
             this.MaximizeBox = false;
             this.MinimizeBox = false;
             this.Name = "InfoForm";

Optimizer/MainForm.cs

@@ -8,12 +8,15 @@ using System.IO;
 using System.Reflection;
 using System.Diagnostics;
 using System.Net;
+using System.Threading;
+using System.Linq;
 
 namespace Optimizer
 {
     public partial class MainForm : Form
     {
         ListViewColumnSorter _columnSorter;
+        AppLinks apps = new AppLinks();
 
         List<StartupItem> _startUpItems = new List<StartupItem>();
         List<string> _hostsEntries = new List<string>();
@@ -361,6 +364,20 @@ namespace Optimizer
 
             txtOS.Text = "Microsoft " + Utilities.GetOS();
             txtBitness.Text = Utilities.GetBitness();
+
+            if (string.IsNullOrEmpty(Options.CurrentOptions.AppsFolder))
+            {
+                txtDownloadFolder.Text = Utilities.DefaultEdgeDownloadFolder;
+                Options.CurrentOptions.AppsFolder = Utilities.DefaultEdgeDownloadFolder;
+                Options.SaveSettings();
+            }
+            else
+            {
+                txtDownloadFolder.Text = Options.CurrentOptions.AppsFolder;
+            }
+
+            c64.Checked = Environment.Is64BitOperatingSystem;
+            c32.Checked = !Environment.Is64BitOperatingSystem;
         }
 
         private void CleanPC()
@@ -679,6 +696,7 @@ namespace Optimizer
 
         private void Main_FormClosing(object sender, EventArgs e)
         {
+            Options.CurrentOptions.AppsFolder = txtDownloadFolder.Text;
             Options.SaveSettings();
         }
 
@@ -1966,5 +1984,157 @@ namespace Optimizer
             HostsHelper.AdBlockWithSocial();
             GetHostsEntries();
         }
+
+        private void RenderAppDownloaderBusy()
+        {
+            btnDownloadApps.Enabled = false;
+            button5.Enabled = false;
+            txtDownloadFolder.ReadOnly = true;
+            c64.Enabled = false;
+            c32.Enabled = false;
+
+            linkLabel1.Visible = false;
+        }
+
+        private void RenderAppDownloaderFree()
+        {
+            btnDownloadApps.Enabled = true;
+            button5.Enabled = true;
+            txtDownloadFolder.ReadOnly = false;
+            c64.Enabled = true;
+            c32.Enabled = true;
+
+            linkLabel1.Visible = !string.IsNullOrEmpty(downloadLog);
+        }
+
+        string appNameTemp = string.Empty;
+        int maxCount = 0;
+        int count = 0;
+
+        string downloadLog = string.Empty;
+
+        private async void btnDownloadApps_Click(object sender, EventArgs e)
+        {
+            RenderAppDownloaderBusy();
+
+            maxCount = 0;
+            count = 0;
+            downloadLog = string.Empty;
+
+            foreach (Control c in Utilities.GetSelfAndChildrenRecursive(appsTab))
+            {
+                if (c is CheckBox && ((CheckBox)c).Checked) maxCount++;
+            }
+
+            CheckBox currentCheck;
+            foreach (AppInfo x in apps.Apps)
+            {
+                if (string.IsNullOrEmpty(x.Tag)) continue;
+                currentCheck = (CheckBox)appsTab.Controls.Find(x.Tag, true)[0];
+                if (currentCheck == null) continue;
+                if (!currentCheck.Checked) continue;
+
+                appNameTemp = x.Title;
+
+                if (c64.Checked)
+                {
+                    count++;
+                    if (x.Link64 == null)
+                    {
+                        downloadLog += "• " + x.Title + ":" + Environment.NewLine + "No 64-bit available, downloading 32-bit" + Environment.NewLine + Environment.NewLine;
+                        await DownloadApp(x, false);
+                    }
+                    else
+                    {
+                        await DownloadApp(x, true);
+                    }
+                }
+                else
+                {
+                    count++;
+                    if (x.Link != null)
+                    {
+                        await DownloadApp(x, false);
+                    }
+                }
+            }
+
+            RenderAppDownloaderFree();  
+        }
+
+        private async Task DownloadApp(AppInfo app, bool pref64)
+        {
+            try
+            {
+                using (WebClient downloader = new WebClient())
+                {
+                    downloader.Headers.Add("User-Agent: Other");
+                    downloader.Encoding = Encoding.UTF8;
+
+                    downloader.DownloadProgressChanged += Downloader_DownloadProgressChanged;
+                    downloader.DownloadFileCompleted += Downloader_DownloadFileCompleted;
+
+                    if (pref64)
+                    {
+                        await downloader.DownloadFileTaskAsync(app.Link64, Path.Combine(txtDownloadFolder.Text, app.Title + "-x64.exe"));
+                    }
+                    else
+                    {
+                        await downloader.DownloadFileTaskAsync(app.Link, Path.Combine(txtDownloadFolder.Text, app.Title + "-x86.exe"));
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                downloadLog += "• " + app.Title + ":" + Environment.NewLine + "Link is no longer valid!" + Environment.NewLine + Environment.NewLine;
+
+                if (pref64) try { File.Delete(Path.Combine(txtDownloadFolder.Text, app.Title + "-x64.exe")); } catch { }
+                if (!pref64) try { File.Delete(Path.Combine(txtDownloadFolder.Text, app.Title + "-x86.exe")); } catch { }
+            }
+        }
+
+        private void Downloader_DownloadFileCompleted(object sender, AsyncCompletedEventArgs e)
+        {
+            this.BeginInvoke((MethodInvoker)delegate
+            {
+                txtDownloadStatus.Text = "Finished";
+            });
+        }
+
+        private void Downloader_DownloadProgressChanged(object sender, DownloadProgressChangedEventArgs e)
+        {
+            this.BeginInvoke((MethodInvoker)delegate
+            {
+                double bytesIn = double.Parse(e.BytesReceived.ToString());
+                double totalBytes = double.Parse(e.TotalBytesToReceive.ToString());
+                double percentage = bytesIn / totalBytes * 100;
+
+                txtDownloadStatus.Text = string.Format("({1}/{2}) - {0} - {3} / {4}", appNameTemp, count, maxCount, ByteSize.FromBytes(e.BytesReceived).ToString("MB"), ByteSize.FromBytes(e.TotalBytesToReceive).ToString("MB"));
+
+                progressDownloader.Value = int.Parse(Math.Truncate(percentage).ToString());
+            });
+        }
+
+        private void button5_Click(object sender, EventArgs e)
+        {
+            FolderBrowserDialog d = new FolderBrowserDialog();
+            if (d.ShowDialog() == DialogResult.OK)
+            {
+                txtDownloadFolder.Text = d.SelectedPath;
+                Options.CurrentOptions.AppsFolder = d.SelectedPath;
+                Options.SaveSettings();
+            }
+        }
+
+        private void button6_Click(object sender, EventArgs e)
+        {
+            Process.Start(txtDownloadFolder.Text);
+        }
+
+        private void linkLabel1_LinkClicked(object sender, LinkLabelLinkClickedEventArgs e)
+        {
+            InfoForm lf = new InfoForm(downloadLog);
+            lf.ShowDialog(this);
+        }
     }
 }

Optimizer/Optimize.cs

@@ -119,11 +119,13 @@ namespace Optimizer
             Utilities.StopService("diagnosticshub.standardcollector.service");
             Utilities.StopService("dmwappushservice");
             Utilities.StopService("DcpSvc");
+            Utilities.StopService("DPS");
 
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DiagTrack", "Start", "4", RegistryValueKind.DWord);
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\diagnosticshub.standardcollector.service", "Start", "4", RegistryValueKind.DWord);
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\dmwappushservice", "Start", "4", RegistryValueKind.DWord);
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DcpSvc", "Start", "4", RegistryValueKind.DWord);
+            Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DPS", "Start", "4", RegistryValueKind.DWord);
         }
 
         internal static void EnableTelemetryServices()
@@ -132,11 +134,13 @@ namespace Optimizer
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\diagnosticshub.standardcollector.service", "Start", "2", RegistryValueKind.DWord);
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\dmwappushservice", "Start", "2", RegistryValueKind.DWord);
             Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DcpSvc", "Start", "2", RegistryValueKind.DWord);
+            Registry.SetValue(@"HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Services\DPS", "Start", "2", RegistryValueKind.DWord);
 
             Utilities.StartService("DiagTrack");
             Utilities.StartService("diagnosticshub.standardcollector.service");
             Utilities.StartService("dmwappushservice");
             Utilities.StartService("DcpSvc");
+            Utilities.StartService("DPS");
         }
 
         internal static void DisableMediaPlayerSharing()

Optimizer/Optimizer.csproj

@@ -82,6 +82,11 @@
     <Compile Include="AboutForm.Designer.cs">
       <DependentUpon>AboutForm.cs</DependentUpon>
     </Compile>
+    <Compile Include="AppInfo.cs" />
+    <Compile Include="AppLinks.cs" />
+    <Compile Include="ByteSize\BinaryByteSize.cs" />
+    <Compile Include="ByteSize\ByteSize.cs" />
+    <Compile Include="ByteSize\DecimalByteSize.cs" />
     <Compile Include="CleanHelper.cs" />
     <Compile Include="EdgeForm.cs">
       <SubType>Form</SubType>

Optimizer/Options.cs

@@ -11,6 +11,7 @@ namespace Optimizer
     public class SettingsJson
     {
         public Theme Color { get; set; }
+        public string AppsFolder { get; set; }
 
         public bool EnablePerformanceTweaks { get; set; }
         public bool DisableNetworkThrottling { get; set; }
@@ -149,6 +150,7 @@ namespace Optimizer
             if (!File.Exists(SettingsFile))
             {
                 CurrentOptions.Color = Theme.Zerg;
+                CurrentOptions.AppsFolder = Utilities.DefaultEdgeDownloadFolder;
 
                 CurrentOptions.EnablePerformanceTweaks = false;
                 CurrentOptions.DisableNetworkThrottling = false;

Optimizer/Program.cs

@@ -13,7 +13,7 @@ namespace Optimizer
         // Enter current version here
 
         internal readonly static float Major = 5;
-        internal readonly static float Minor = 1;
+        internal readonly static float Minor = 2;
 
         internal static string GetCurrentVersionTostring()
         {

README.md

@@ -14,6 +14,7 @@ Depending on your version of Windows, Optimizer will also allow you to perform s
 * Disable Office telemetry (works only with 2016)
 * Disable Cortana
 * Disable Windows 10 automatic updates
+* Download useful apps quickly at once
 * Uninstall UWP apps
 * Clean up your system drive
 * Fix common registry issues
@@ -43,5 +44,5 @@ https://github.com/hellzerg/optimizer/blob/master/CHANGELOG.md
 
 ## Details: ##
 
-* Latest version: 5.1
-* Released: December 11, 2020
+* Latest version: 5.2
+* Released: December 17, 2020

version.txt

@@ -1 +1 @@
-5.1
+5.2