Softpedia >Windows >Programming >Components & Libraries >DotNetBrowser >  Changelog

DotNetBrowser Changelog

What's new in DotNetBrowser 2.26.2

Apr 24, 2024
  • We upgraded Chromium to a newer version, which introduces multiple security fixes that prevent a remote attacker who had compromised the GPU process from potentially perform a sandbox escape via specific UI gestures, potentially exploit heap corruption via a crafted HTML page, including:
  • CVE-2024-3157: Out of bounds write in Compositing
  • CVE-2024-3516: Heap buffer overflow in ANGLE
  • CVE-2024-3515: Use after free in Dawn
  • CVE-2024-3159: Out of bounds memory access in V8
  • Quality enhancements:
  • The print preview is now placed properly in BrowserView when entering the full-screen window mode on macOS.
  • In the off-screen rendering mode, the IME candidate window in Avalonia closes when the BrowserView is clicked.
  • In the off-screen rendering mode, the Chromium engine no longer crashes on Windows when BrowserView is used with accessibility tools.
  • The ArgumentException is no longer thrown from the Avalonia BrowserView when it is not added to the visual tree yet.
  • The IEngine.Disposed event is no longer raised twice.

New in DotNetBrowser 2.26.1 (Mar 28, 2024)

  • Chromium upgraded to 122.0.6261.94:
  • We upgraded Chromium to a newer version, which introduces multiple security fixes that prevent a remote attacker from potentially exploiting the heap corruption via a crafted HTML page, including:
  • CVE-2024-1669: Out of bounds memory access in Blink
  • CVE-2024-1670: Use after free in Mojo
  • CVE-2024-1938: Type Confusion in V8
  • CVE-2024-1939: Type Confusion in V8
  • Quality enhancements:
  • An intermittent OverflowException is no longer thrown in the off-screen rendering mode when it is used on 4K displays.
  • The .NET process does not crash occasionally after clicking anywhere in the application window.

New in DotNetBrowser 2.26.0 (Feb 27, 2024)

  • Casting API:
  • It’s now possible to cast media content directly from DotNetBrowser to the devices supported by Chromium
  • Chromium upgraded to 121.0.6167.184:
  • We upgraded Chromium to a newer version, which introduces multiple security fixes that prevent a remote attacker to potentially exploit heap corruption via a crafted HTML page or malicious file, including:
  • CVE-2024-1284: Use after free in Mojo
  • CVE-2024-1283: Heap buffer overflow in Skia
  • CVE-2024-1060: Use after free in Canvas
  • CVE-2024-1059: Use after free in WebRTC
  • CVE-2024-1077: Use after free in Network
  • CVE-2024-0807: Use after free in WebAudio
  • CVE-2024-0812: Inappropriate implementation in Accessibility
  • CVE-2024-0808: Integer underflow in WebUI
  • Quality enhancements:
  • The BrowserView in Avalonia UI now provides a better IME support in the off-screen rendering mode.
  • The InvalidOperationException is no longer thrown when the Loaded event occurs for the BrowserView which is not yet placed on the WPF window.
  • The memory leak is no longer observed when adding and removing WinForms BrowserViews working in the off-screen rendering mode.

New in DotNetBrowser 2.25.1 (Jan 22, 2024)

  • Chromium upgraded to 120.0.6099.216:
  • We upgraded Chromium to a newer version, which introduces multiple security fixes, including:
  • CVE-2024-0333: Insufficient data validation in Extensions
  • Quality enhancements:
  • The default OpenFileHandler in Avalonia UI now respects the suggested start location provided by Chromium.

New in DotNetBrowser 2.25.0 (Dec 28, 2023)

  • The DotNetBrowser.Templates package now contains one more template - a simple Blazor Hybrid application that utilizes the capabilities of Avalonia UI and DotNetBrowser to run Razor components in a desktop app. This approach can be used to build a cross-platform desktop application and construct its UI using both Blazor and Avalonia UI capabilities, sharing a large amount of code between web and desktop. See our Quick Start guide for more details.

New in DotNetBrowser 2.24.2 (Nov 22, 2023)

  • Quality enhancements:
  • The ObjectDisposedException is no longer thrown on closing a form that embeds DotNetBrowser.
  • The CSS3 cursors are now sized properly on macOS.
  • The “Paste” option from the default Avalonia context menu implementation now works as expected for the input fields on macOS.
  • The autofill suggestions popup in Avalonia is now displayed in the correct initial location and is closed properly when the window loses focus.

New in DotNetBrowser 2.24.1 (Oct 20, 2023)

  • Improved the IsSession property behavior in CanSetCookieHandler.
  • Fixed an issue with the unselectable combo box in WPF touchscreen applications in the offscreen rendering mode.
  • Fixed an issue with an exception handling in the default context menu.

New in DotNetBrowser 2.24 (Oct 3, 2023)

  • Avalonia UI
  • We’re delighted to announce DotNetBrowser’s support for Avalonia UI!
  • With yet another integration in the toolbox, DotNetBrowser has become the most versatile web view control for .NET on Windows, Linux, and macOS.

New in DotNetBrowser 2.23.3 (Sep 6, 2023)

  • Quality enhancements:
  • Added support for the H265/HEVC codec.
  • Improved the behavior of the BrowserView toolbox component in WinForms applications (DotNetBrowser VSIX package).
  • Enabled overriding of the AmbientAuthenticationInPrivateModesEnabled policy.
  • Improved initial locations of dialog windows.

New in DotNetBrowser 2.23.2 (Aug 3, 2023)

  • Chromium:
  • We’ve upgraded Chromium to version 115.0.5790.99. This update includes 20 security fixes.
  • Quality enhancements:
  • Fixed an issue with printing via system printer.
  • Fixed an issue when AJAX requests did not work with custom URI scheme.

New in DotNetBrowser 2.23.1 (Jun 22, 2023)

  • Quality enhancements:
  • Fixed application freeze caused by the default BeforeUnloadHandler.
  • Fixed application freeze caused by “Save credit card” dialog.
  • Fixed DRM content playback issue.
  • Fixed the inability to put focus on the input field after confirming modal dialog.
  • Improved parent window detection if there is no parent WPF or WinForms window.
  • DevTools window title now displays the URL of the opened page.

New in DotNetBrowser 2.23 (May 25, 2023)

  • Touchscreen support:
  • Starting with this update, DotNetBrowser works on touchscreen devices in the off-screen rendering mode. That includes scroll, long-press, pinch-to-zoom, and content rotation.
  • Full touch and gestures support is available in WPF. In WinForms, this functionality is limited to tapping and long-pressing, because touch support in WinForms itself is limited.
  • Chromium:
  • We upgraded Chromium to version 113.0.5672.63 which includes 15 security fixes.
  • Quality enhancements:
  • Improved JavaScript-.NET bridge performance and memory usage.
  • Added a warning log on attempts to use a non-supported paper size when printing.
  • Resolved appearance of System.IO.FileNotFoundException: "Could not load file or assembly 'DotNetBrowser.Core.XmlSerializers'" first-chance exception caught by debuggers.

New in DotNetBrowser 2.22.1 (Apr 27, 2023)

  • Chromium 112:
  • In this release, we upgraded Chromium engine to version 112.0.5615.137 that includes 8 security fixes.
  • Default font size:
  • Modify the default font size of the webpage loaded in IBrowser instance with the help of a new setting:
  • browser.Settings.DefaultFontSize = 22;
  • Quality enhancements:
  • Fixed issue when HTML5 color picker did not function properly.
  • Switched pixel format to Pbgra32 that slightly improves off-screen rendering performance in WPF.
  • The path to a log file is now automatically created if it does not exist.

New in DotNetBrowser 2.22 (Mar 23, 2023)

  • Fixed issue with custom cursors scaling on HiDPI monitors.
  • Fixed issue when PDF viewer did not display some Turkish characters.

New in DotNetBrowser 2.21 (Feb 27, 2023)

  • Quality enhancements:
  • Fixed Chromium crash on browser creation and closing.
  • Chromium:
  • We upgraded Chromium to version 110.0.5481.77. This update includes 15 security fixes.
  • Camera and microphone events:
  • Chromium shows red dot on the tab which uses camera or microphone. We added the possibility to detect the usage of this devices programmatically

New in DotNetBrowser 2.20.1 (Feb 7, 2023)

  • Quality enhancements:
  • Fixed issue when point inspection returned DOM node objects bound to an incorrect frame.

New in DotNetBrowser 2.19 (Dec 28, 2022)

  • Chromium 108:
  • We upgraded Chromium to version 108.0.5359.125 which includes 8 important security fixes.
  • Late binding support for VB.NET:
  • We’ve improved the existing dynamic support to make it work better for VB.NET. It is now possible to get JavaScript object properties with late binding.
  • Quality enhancement:
  • Fixed GPU crashes while taking screenshots in off-screen rendering mode.

New in DotNetBrowser 2.19 (Dec 5, 2022)

  • ARM:
  • Use DotNetBrowser on Linux and macOS with ARM64 architecture.
  • The library has been tested with the following hardware and software:
  • Raspberry Pi 2 (A 900MHz quad-core ARM Cortex-A7 CPU) and AWS (AWS Graviton Processors) with Ubuntu 20.04 LTS
  • Apple Silicon M1 with macOS Big Sur
  • The library includes Chromium binaries compiled for ARM architecture. See what packages to install in your project for Linux and macOS.
  • Accessibility:
  • The blind and visually impaired users can now read the text on the web pages displayed in DotNetBrowser using the special software like Narrator or JAWS. It works in both rendering modes: off-screen and hardware accelerated.
  • .NET 7:
  • Feel free to use DotNetBrowser with .NET 7 which has been recently released.
  • Quality enhancements:
  • Fixed the issue when FCM notification doesn’t appear even when permission is granted.
  • The default SelectCertificate dialog no longer appears if there is no client certificate to select.

New in DotNetBrowser 2.18 (Oct 21, 2022)

  • Chromium:
  • We’ve upgraded Chromium to version 106.0.5249.119. It includes fixes from Chromium 105, Chromium 106, and the latest Stable channel update.
  • Navigation:
  • The LoadResult was replaced with NavigationResult to provide more details about the possible navigation failure. Before this change, the LoadUrl() method returned Task<LoadResult> that could only be used to determine whether the navigation has succeeded or failed.
  • Quality enhancements:
  • Fixed possible memory leaks when creating and disposing of browsers.

New in DotNetBrowser 2.17 (Oct 5, 2022)

  • Support of the Apple Silicon and ARM64 platforms is on our Roadmap. The official support for these platforms will be added in one of the nearest releases.
  • Cross-platform GUI:
  • The support for cross-platform UI libraries is yet to come. If you are interested in using DotNetBrowser in UI, drop us a message.
  • Chromium 104:
  • The Chromium engine has been upgraded to version 104.0.5112.124.
  • Name converter for JavaScript injected objects:
  • ConvertJsNameHandler allows converting .NET method/property/field names to the name that will be used in JavasScript. See an example in our GitHub repository: C# and VB.NET.
  • Fullscreen API:
  • It is now possible to exit fullscreen programmatically. It works even for PDF viewer:
  • browser.FullScreen.Exit();
  • There are some backward incompatible API changes you can read about in our migration guide.
  • Quality enhancements:
  • Fixed IEngine instance crash after closing DevTools window.
  • Improved string indexer support in JS-.NET bridge to make it work with ExpandoObject.
  • Download DotNetBrowser 2.17 .NET Framework
  • Download DotNetBrowser 2.17 .NET Core
  • Download DotNetBrowser 2.17 Cross-platform

New in DotNetBrowser 2.16.1 (Aug 23, 2022)

  • We’ve added the possibility to create IEngine asynchronously:
  • public Form1()
  • InitializeComponent();
  • EngineFactory.CreateAsync(new EngineOptions.Builder()
  • RenderingMode = RenderingMode.HardwareAccelerated
  • }.Build()).ContinueWith(t =>
  • engine = t.Result;
  • browser = engine.CreateBrowser();
  • browserView.InitializeFrom(browser);
  • browser.Navigation.LoadUrl("google.com");
  • }, TaskScheduler.FromCurrentSynchronizationContext());
  • Quality enhancement:
  • Fixed the issue when IME caused unexpected application termination in Off-screen rendering mode.

New in DotNetBrowser 2.16 (Aug 8, 2022)

  • Chromium:
  • Chromium has been upgraded to version 102.0.5005.167. It includes the critical security fix.
  • WebAuthn support:
  • It is now possible to authenticate using hardware tokens or built-in platform authenticators such as fingerprint sensors.
  • Redesigned spellchecker API:
  • Meet a new improved spellchecking API. Check out changes in our migration guide and updated article.
  • Encrypted PDFs:
  • The password-protected PDFs can now be opened in DotNetBrowser. By default, the standard Chromium dialog is shown when the encrypted PDF is loaded.
  • To provide password programmatically, or cancel the password request, use RequestPdfDocumentPasswordHandler

New in DotNetBrowser 2.15.1 (Jun 17, 2022)

  • Chromium has been upgraded to version 102.0.5005.115

New in DotNetBrowser 2.15 (Jun 14, 2022)

  • Fixed issues:
  • Black flickering when showing and hiding BrowserView on Windows in the hardware-accelerated rendering mode.
  • The inability to put focus on the input field after closing alert dialog.
  • NullReferenceException being shown when creating a DOM key event.

New in DotNetBrowser 2.14 (May 1, 2022)

  • Widevine CDM initialized with a significant delay.
  • The in-process DevTools window was not draggable in Windows 7 environment.

New in DotNetBrowser 2.13.1 (Apr 12, 2022)

  • Chromium has been upgraded to version 100.0.4896.75. This version includes 1 important security fix.

New in DotNetBrowser 2.13 (Apr 7, 2022)

  • Chromium has built-in functionality that is used to store the entered credentials after the user submits a web form with a username and password. In this case, the SavePasswordHandler and UpdatePasswordHandler handlers will be used to decide whether to save credentials or update them if they are already saved.
  • The Chromium engine has been upgraded to version 100.0.4896.60.
  • This Chromium version includes many security fixes, so we recommend that you upgrade to this version.
  • This release brings the extended support of collections in the JS-.NET bridge.
  • The IJsArray, IJsSet, IJsMap and IJsArrayBuffer interfaces were added to simplify work with JavaScript collections from the .NET side.

New in DotNetBrowser 2.12 (Mar 23, 2022)

  • Chromium 98:
  • The Chromium engine has been upgraded to version 98.0.4758.102.
  • This Chromium version includes many security fixes, so we recommend that you upgrade to this version.
  • IME support:
  • Now, you can enter text in Chinese, Japanese, Korean, etc. using IME in the off-screen rendering mode both in WPF and WinForms applications.
  • IME:
  • EngineFactory.Create() method overload
  • Specifying the required rendering mode became easier:
  • IEngine engine = EngineFactory.Create(RenderingMode.HardwareAccelerated);
  • Handling smart cards:
  • It is now possible to unlock the smart card and provide its PIN programmatically:
  • Quality enhancements:
  • The “Paste” option has been added to the default context menu implementation.
  • The “Save as” dialog now properly displays the “Save as type” option and file extensions.
  • Fix the issue when current thread culture breaks the DOM node creation logic.
  • Fix the issue when SSL certificate revocation status is not being detected.

New in DotNetBrowser 2.11 (Jan 14, 2022)

  • Chromium 96:
  • Chromium has been upgraded to version 96.0.4664.110.
  • This Chromium version includes 5 security fixes, so we recommend that you upgrade to this version.
  • Intercepting touch events:
  • It is now possible to handle touch events using the following handlers: Touch.Started.Handler, Touch.Moved.Handler, Touch.Canceled.Handler and Touch.Ended.Handler
  • Simulating touch events:
  • The touch event can be simulated with the help of browser.Touch.Started, browser.Touch.Moved and browser.Touch.Ended
  • System.Guid:
  • The JS-.NET bridge functionality has been extended. Now you can inject the System.Guid structure into JavaScript and obtain it as an object from JavaScript.
  • DOM Image Element:
  • DOM API has been extended with the IImageElement interface. It allows fetching image contents from the IMG tag:
  • IImageElement element = document.GetElementByTagName("img") as IImageElement;
  • Bitmap contents = element.Contents;
  • Improvements:
  • The VS 2022 VSIX package compatibility has been added.
  • Posted on January 03, 2022
  • What’s new
  • Chromium 96
  • Chromium has been upgraded to version 96.0.4664.110.
  • This Chromium version includes 5 security fixes, so we recommend that you upgrade to this version.
  • Intercepting touch events
  • It is now possible to handle touch events using the following handlers: Touch.Started.Handler, Touch.Moved.Handler, Touch.Canceled.Handler and Touch.Ended.Handler. See example below:
  • private void Subscribe(IBrowser browser)
  • // Subscribe touch started event
  • browser.Touch.Started.Handler = new Handler<ITouchEventArgs, InputEventResponse>(e =>
  • ITouchPoint point = e.TouchPoints.First(p => p.TouchState == TouchState.Started);
  • Console.WriteLine($@"Touch {point.Id} started at -
  • ({point.LocationOnWidget.X} : {point.LocationOnWidget.X})");
  • return InputEventResponse.Proceed;
  • });
  • // Subscribe touch moved event
  • browser.Touch.Moved.Handler = new Handler<ITouchEventArgs, InputEventResponse>(e =>
  • ITouchPoint point = e.TouchPoints.First(p => p.TouchState == TouchState.Moved);
  • Console.WriteLine($@"Touch {point.Id} moved to -
  • ({point.LocationOnWidget.X} : {point.LocationOnWidget.X})");
  • return InputEventResponse.Proceed;
  • });
  • // Subscribe touch canceled event
  • browser.Touch.Canceled.Handler = new Handler<ITouchEventArgs, InputEventResponse>(e =>
  • ITouchPoint point = e.TouchPoints.First(p => p.TouchState == TouchState.Canceled);
  • Console.WriteLine($@"Touch {point.Id} canceled at -
  • ({point.LocationOnWidget.X} : {point.LocationOnWidget.X})");
  • return InputEventResponse.Proceed;
  • });
  • // Subscribe touch ended event
  • browser.Touch.Ended.Handler = new Handler<ITouchEventArgs, InputEventResponse>(e =>
  • ITouchPoint point = e.TouchPoints.First(p => p.TouchState == TouchState.Ended);
  • Console.WriteLine($@"Touch {point.Id} ended at -
  • ({point.LocationOnWidget.X} : {point.LocationOnWidget.X})");
  • return InputEventResponse.Proceed;
  • });
  • Simulating touch events
  • The touch event can be simulated with the help of browser.Touch.Started, browser.Touch.Moved and browser.Touch.Ended input events:
  • private void SimulateTouches(IBrowser browser)
  • browser.Focus();
  • // Start touch with ID = 0 at location (10, 10)
  • browser.Touch.Started.Raise(
  • new TouchStartedEventArgs(
  • new TouchPoint(0, TouchState.Started, new Point(10, 10))));
  • Thread.Sleep(500);
  • // Shifting touch with ID = 0 on 5 pixels along x axis
  • browser.Touch.Moved.Raise(
  • new TouchMovedEventArgs(
  • new TouchPoint(0, TouchState.Moved, new Point(15, 10))));
  • Thread.Sleep(500);
  • // End touch with ID = 0 at location (10, 10)
  • browser.Touch.Ended.Raise(
  • new TouchEndedEventArgs(
  • new TouchPoint(0, TouchState.Ended, new Point(15, 10))));
  • Thread.Sleep(500);
  • // Start touch with ID = 1 at location (10, 10)
  • browser.Touch.Started.Raise(
  • new TouchStartedEventArgs(
  • new TouchPoint(1, TouchState.Started, new Point(10, 10))));
  • Thread.Sleep(500);
  • // Shifting touch with ID = 1 on 5 pixels along x axis
  • browser.Touch.Moved.Raise(
  • new TouchMovedEventArgs(
  • new TouchPoint(1, TouchState.Moved, new Point(15, 10))));
  • Thread.Sleep(500);
  • // Cancel touch with ID = 1 at location (10, 10)
  • browser.Touch.Canceled.Raise(
  • new TouchCanceledEventArgs(
  • new TouchPoint(1, TouchState.Canceled, new Point(10, 10))));
  • Thread.Sleep(500);
  • System.Guid
  • The JS-.NET bridge functionality has been extended. Now you can inject the System.Guid structure into JavaScript and obtain it as an object from JavaScript.
  • DOM Image Element
  • DOM API has been extended with the IImageElement interface. It allows fetching image contents from the IMG tag:
  • IImageElement element = document.GetElementByTagName("img") as IImageElement;
  • Bitmap contents = element.Contents;
  • Improvements
  • The VS 2022 VSIX package compatibility has been added.
  • Fixed issues:
  • AlertHandler causing the entire application to freeze.

New in DotNetBrowser 2.10 (Nov 18, 2021)

  • Chromium has been upgraded to version 94.0.4606.113.
  • In March 2021, Google announced that Chrome/Chromium is planning to release a new milestone every 4 weeks, starting with Chrome/Chromium 94 in Q3 of 2021. Additionally, they added a new Extended Stable option, with milestone updates every 8 weeks. Security updates on Extended Stable will be released every two weeks to fix important issues, however, those updates won’t contain new features or all security fixes that the 4-week option will receive.
  • This Chromium build is part of the Extended Stable update. It includes all security fixes and new features introduced in Chromium 94.
  • As usual, we recommend you to use the latest DotNetBrowser version with the latest Chromium build.
  • Screen sharing:
  • We extended the API with new functionality that allows you to work with Chromium screen sharing feature. If the page requests to share your screen, the standard Chromium dialog will be shown:
  • WebRTC:
  • This dialog lets you choose whether to share the entire screen, a specific window, or a web page loaded in other Browser instances.
  • Our API also provides the possibility to share your screen programmatically
  • Printing:
  • Header and Footer:
  • Now you can set a custom header and footer for the programmatically printed document without displaying the Print Preview dialog. For example:
  • browser.PrintHtmlContentHandler
  • = new Handler<PrintHtmlContentParameters, PrintHtmlContentResponse>(p =>
  • PdfPrinter<PdfPrinter.IHtmlSettings> pdfPrinter = p.Printers.Pdf;
  • IPrintJob<PdfPrinter.IHtmlSettings> printJob = pdfPrinter.PrintJob;
  • printJob.Settings.Apply(printSettings =>
  • // Enable header and footer.
  • printSettings.PrintingHeaderFooterEnabled = true;
  • // Set custom header and footer.
  • printSettings.HeaderTemplate =
  • "<span style="font-size: 12px;">" +
  • "Page header:" +
  • "<span class='title'></span></div>";
  • printSettings.FooterTemplate =
  • "<span style="font-size: 12px;">" +
  • "Page number: <span class='pageNumber'>" +
  • "</span> of <span class='totalPages'></span></div>";
  • printSettings.PdfFilePath =
  • Path.Combine(Directory.GetCurrentDirectory(),
  • "test.pdf");
  • });
  • return PrintHtmlContentResponse.Print(pdfPrinter);
  • });
  • Scaling:
  • You can change scaling for the printed document. In the case of custom scaling, the scale amount must be a number between 10 and 200:
  • browser.PrintHtmlContentHandler
  • = new Handler<PrintHtmlContentParameters, PrintHtmlContentResponse>(p =>
  • PdfPrinter<PdfPrinter.IHtmlSettings> pdfPrinter = p.Printers.Pdf;
  • IPrintJob<PdfPrinter.IHtmlSettings> printJob = pdfPrinter.PrintJob;
  • printJob.Settings.Apply(printSettings =>
  • // Set custom scaling.
  • printSettings.Scaling = Scaling.Custom(130);
  • printSettings.PdfFilePath =
  • Path.Combine(Directory.GetCurrentDirectory(), "test.pdf");
  • });
  • return PrintHtmlContentResponse.Print(pdfPrinter);
  • });
  • Fixed issues:
  • An empty tooltip displayed for the BrowserView in Off-screen rendering mode.
  • The entire application freezing when the popup window with the content viewer is closed.
  • Entering fullscreen mode failure when the video player is embedded in an iframe.
  • The upload data parser not working properly with empty values.
  • The inability to disable the touch menu via TouchMenuDisabled IEngine option.
  • The improper keyboard focus behavior with multiple BrowserView instances on the same window.

New in DotNetBrowser 2.9 (Sep 24, 2021)

  • Fixed issues:
  • Keyboard focus being lost in the WPF application when reconnecting to the remote computer via RDP.
  • Focus flickering when launching multiple BrowserView instances.

New in DotNetBrowser 2.8 (Aug 21, 2021)

  • Chromium:
  • In this version, we upgraded Chromium to version 91.0.4472.164 that includes 8 important security fixes.
  • Network connection state:
  • Now you can get notifications when the network connection state is changed.
  • Chromium internally tracks the Internet connection status. When the Internet connection is dropped and then restored, Chromium detects this and programmatically reloads the currently loaded web page.
  • Cookie API:
  • We figured out that the URL parameter is used by Chromium only to validate the given cookie and check its domain. We decided to modify this API to simplify it.
  • Now, you don’t have to pass the URL parameter and make sure that the URL and cookie’s domain are the same. Now, you can set a cookie using the following simple way:
  • Fixed issues:
  • The focus not restored after unfocusing and focusing on BrowserView located inside ElementHost.
  • The WinForms BrowserView instance becoming invisible after reattaching it to a Form in the heavyweight rendering mode.
  • The keyboard focus not restored on the input field after minimizing/restoring the window.
  • The .NET memory leak observed when obtaining the same JavaScript object several times.
  • Proxy authentication not working with Incognito mode.

New in DotNetBrowser 2.7 (Jul 26, 2021)

  • Fixed issues:
  • BrowserView getting blank while resizing the parent window to fullscreen in Off-screen rendering mode, while DotNetBrowser is embedded as a VSTO Add-In.
  • The focus not restoring to the webpage after closing the PrintPreview dialog.
  • Improvements:
  • It is now possible to work with JavaScript promises via IJsPromise type.
  • IFrame.Text property has been added. It allows getting content of a frame as plain text.
  • The focus behavior for the WinForms BrowserView control in WPF applications has been improved.
  • The SetWindowDisplayAffinity() WinAPI function used with WDA_MONITOR parameter no longer causes a Chromium crash when navigating to a different domain.

New in DotNetBrowser 2.6 (May 27, 2021)

  • Improvements:
  • The focus is now handled better when WPF BrowserView is embedded into a WinForms application.
  • The default dialogs in both WPF and WinForms now have better layouts.
  • Fixed Issues:
  • The keyboard focus in WPF and WinForms applications is now properly set after minimizing and restoring or deactivating and activating the window.
  • Session cookies are now properly saved after the browser is disposed, and the engine is reused for creating another browser.

New in DotNetBrowser 2.5 (Apr 7, 2021)

  • What’s New:
  • Chromium 88:
  • Chromium engine in DotNetBrowser 2.5 has been updated to version 88.0.4324.182.
  • In this Chromium build some of its features wrapped with the DotNetBrowser have been removed or changed, so this DotNetBrowser version introduces several breaking changes in the public API. Check out the migration guide for this version to see what API has been changed/removed and what alternatives you should use instead.
  • External Apps:
  • Some applications installed in the operating system might be associated with a specific URI scheme. When a user navigates to a URL with such a scheme, Chromium displays a dialog where the user can decide whether the link should be opened in the associated external application or not.
  • With this update you can use OpenExternalAppHandler to intercept such cases and display your own dialog to the end users or programmatically open the external application without prompting the user.
  • Fixed Issues:
  • Entering combined characters in the off-screen rendering mode. Such cases like the combination of ´ and e resulting in two separate characters in French are no longer an issue.
  • The removal of BrowserView from parent form in WinForms not being detected, leading to various focus issues.
  • Read/write permissions for JavaScript Clipboard API always being denied despite the RequestPermissionHandler implementation.
  • Improvements:
  • DotNetBrowser now supports the same list of UI languages as Chromium does.
  • It is now possible to display the BeforeUnload dialog when disposing IBrowser.
  • FIPS compliance was restored. It is now possible to use DotNetBrowser in the environments where the Federal Information Processing Standard restriction policy is enabled.

New in DotNetBrowser 2.4 (Mar 3, 2021)

  • NEW:
  • Printing API:
  • The Printing API is back – improved and redesigned. Now you can print pages and documents as well as savе web pages to PDF silently from the code.
  • With the new Printing API you can:
  • select a printer device;
  • provide the required print settings such as paper size, orientation, page ranges, etc.;
  • get notifications when printing is completed;
  • cancel printing;
  • save the currently loaded web page to a PDF document and more.
  • .NET 5 support:
  • DotNetBrowser is tested and proven to integrate with .NET 5 desktop applications.
  • IMPROVEMENTS:
  • The Print Preview dialog has been clipped off from the top of the form and positioned lower to improve user experience.
  • AuthenticateParameters.Realm property was added to provide the realm of the authentication challenge.
  • FIXED ISSUES:
  • Excessive CPU and GPU usage by the native process with multiple tabs with WPF BrowserView instances in the hardware-accelerated mode.
  • WPF BrowserView crashing in the hardware-accelerated mode.
  • Few memory leaks for registering/unregistering .NET objects via JS-.NET bridge.
  • The Tab key not working properly with WPF BrowserView.
  • The scrolling of a page stopping if the mouse pointer is hovered out of WPF BrowserView component in the Off-screen rendering mode.
  • The focus traversal entering the infinite loop when displaying a popup.

New in DotNetBrowser 2.3 (Nov 26, 2020)

  • What’s New:
  • Chromim 84:
  • Chromium has been updated to version 84.0.4147.135.
  • In this Chromium build some of its features wrapped with the DotNetBrowser have been removed or changed, so this DotNetBrowser version introduces several breaking changes in the public API.
  • Properties and fields access in JS-.NET bridge:
  • Access the public properties and fields of a .NET object injected into JavaScript through the JS-.NET Bridge API. The JS-.NET Bridge API allows injecting .NET objects into JavaScript and to call their public methods. Starting from this version it can work with the public properties and fields as well.
  • Drag and Drop events interception and IDataObject support:
  • In this version the IDragAndDrop.EnterDragHandler and IDragAndDrop.DropHandler were added. These handlers can be used to intercept the corresponding drag and drop events on web pages in the hardware-accelerated rendering mode.
  • Improvements:
  • The default StartDownloadHandler implementation is now configured during the BrowserView initialization if a custom StartDownloadHandler was not configured for the corresponding IBrowser instance.
  • The default SelectCertificateHandler implementation was added. This implementation is configured during the BrowserView initialization if a custom handler was not configured for the corresponding IBrowser instance.
  • The SelectCertificateResponse.Select(Certificate) method functionality was improved. This method was previously used for the custom certificates only. Now, it will work properly for the certificates from the handler parameters.
  • The UrlRequest class was extended with the following properties: Browser, ResourceType, SslVersion. All these properties can be used to obtain more information about this URL request, including the browser that initiated this request, the type of the requested resource, and the SSL version used to perform the request.
  • SuggestedFileName and SuggestedDirectory were added to the SaveAsPdfParameters. These properties can be used to obtain the suggested path to save the PDF file in the SaveAsPdfHandler.
  • The DOM key events were extended with the Character property. Now it is possible to get the character generated by pressing the key and associated with the intercepted DOM key event.
  • The INavigation.CurrentIndex property was added.
  • The Cookie.SameSite property was added.
  • Fixed Issues:
  • ShowNetErrorPageHandler not working properly for websites with invalid certificates.
  • Increased page load time when loading the same page several times.
  • The memory leak caused by some of the internal objects not being released after disposing Browser.
  • The DoubleClick DOM events not received from the web page.
  • The Visibility property binding not working properly for WPF BrowserView.
  • Context menu being shown only once for the Flash objects.
  • Context menu not being shown for PDF files opened in the browser.
  • A few memory leaks for registering/unregistering .NET objects via JS-.NET bridge.
  • BrowserView not being shown on the second TabItem after initializing.
  • CSS 3 cursors not displaying properly in Windows 7 and Windows 2008 R2 environments.
  • The incorrect image location in WPF BrowserView in the hardware-accelerated mode.
  • Focus not being restored for WinForms BrowserView after displaying and closing the default dialog in BeforeUnloadHandler.

New in DotNetBrowser 2.2 (Sep 9, 2020)

  • What's New:
  • Rendering Performance:
  • The off-screen rendering performance has been improved on all supported platforms and UI toolkits.
  • Chromium Traffic:
  • It is now possible to save on unnecessary traffic to such Chromium services as Google Cloud Messaging, Translate Ranker, Extensions Updater, Safe Browsing, etc. These services are related to the features that are not currently supported in DotNetBrowser.
  • Disabling PDF Viewer:
  • You can now choose whether to display PDF documents in the PDF Viewer or download them. By default, they will be displayed in the PDF Viewer.
  • Clearing HTTP Cache:
  • With this update you get more control over the memory usage. You can now mark all HTTP cache entries stored in both disk and memory for deletion.
  • Important: The IHttpCache.ClearDiskCache() method is marked as Obsolete and will be removed in one of the next versions. Use the IHttpCache.Clear() method instead.
  • Overscroll History Navigation:
  • DotNetBrowser now allows navigating back/forward with a left/right swipe on devices with the touch screen. By default, the overscroll navigation is disabled.
  • Focused DOM Element:
  • It is now possible to get the currently focused DOM element in the document.
  • IPC Message Order:
  • In the previous versions the IPC message order could be changed when any handler was invoked. For example, raising the keyboard events method when a handler is invoked could lead to an issue when the text field on a web page contained randomly mixed letters.
  • Improvements:
  • In the previous versions, the same user data directory is used for all the IEngine instances that have no custom user data directory specified. This directory usually contained previously saved data such as proxy settings, cookies, cache, etc.
  • In this release, a separate temporary user data directory is created each time when an IEngine instance is created without specifying the custom user data directory. This directory is deleted automatically during disposing the IEngine instance.
  • Fixed Issues:
  • The overridden HTTP headers causing ‘400 Bad Request’ error.
  • The ArgumentException error when moving a child form with BrowserView instance out of the main WinForms form using hardware-accelerated rendering mode.
  • The SpellChecker functionality not working after migration to Chromium 79.
  • The second BrowserView instance not showing the webpage when using hardware-accelerated rendering mode in WinForms applications.
  • Getting a DOM node from the XPathResult leading to hang.
  • Wrong IKeyTypedEventArgs.VirtualKey value when using hardware-accelerated rendering mode.
  • The NullReferenceException error when the MIME type is not set in OnHeadersReceived callback.
  • The popup window not being closed properly.

New in DotNetBrowser 2.1.1 (Jul 2, 2020)

  • Improvement:
  • Updated searching assemblies algorithm for the Global Assembly Cache.
  • Fixed issues:
  • InvalidOperationException: “This Visual is not connected to a PresentationSource.” thrown when moving, minimizing or maximizing a BrowserView control in WPF applications in both rendering modes.
  • Unpredictable behavior when using BrowserView controls inside TabControls or equivalent.

New in DotNetBrowser 1.21.1 (Oct 24, 2019)

  • Improvements:
  • We have added the sign to the GZipCompress.exe utility, which will reduce the number of errors with firewalls, antiviruses and other security software, when launching applications, containing DotNetBrowser.
  • The embedding process of the WinFormsBrowserView component in a WPF application got better. Now pop up windows are available upon embedding.
  • Fixed issues:
  • The InvalidCastException occurring because of the new PermissionRequest.PermissionType values in Chromium 69.
  • The InvalidOperationException occurring with the Channel already closed exception if registering a protocol handler for two or more BrowserContext instances.

New in DotNetBrowser 1.21 (Aug 20, 2019)

  • Certificate chain:
  • The CertificateVerifyParams.IntermediateCertificates property allows getting the intermediate certificate list retrieved from the server that can be used to reconstruct and verify the complete certificate chain.
  • Disable form autofill functionality:
  • The BrowserContext.AutoFillEnabled property allows enabling or disabling auto-fill functionality.
  • JavaScript requests focus:
  • The Browser.FocusRequested event allows getting notifications when JavaScript requests setting focus to a Browser instance.
  • Hide scrollbars:
  • The --hide-scrollbars switcher allows hiding scroll bars on the web pages. It might come handy when taking an image of a webpage.
  • Improvement:
  • The Chromium binaries verification process now respects the modification date.
  • Fixed issues:
  • The pop-up window does not respect the passed size and location.
  • The NullReferenceException in SpellCheckerService and ZoomService for the second and subsequent BrowserContext instances during application runtime.
  • The issue with finding the full path to the DotNetBrowser.ChromiumX.dll files.
  • The WinFormsBrowserView component in the heavyweight rendering mode is disposed even if it is removed from the child list of the form and the form is closed.
  • The usage of the back and forward mouse buttons in WPFBrowserView (heavyweight rendering mode) leads to the System.InvalidCastException exception.
  • The offline JavaScript service workers are not initialized properly.

New in DotNetBrowser 1.20.1 (Jun 12, 2019)

  • Version 1.20.1 features several important improvements adding up to the library's convenience and productivity:
  • Now you can easily check if the binaries use proprietary codecs with the new ChromiumBinaries.IsCodecEnabled property.
  • It got simple to look the Chromium version up – just check the Product version property of assemblies.
  • Use DotNetBrowser conveniently with toolbox support for Visual Studio 2019.
  • The new dispose logic allows the instance not to wait until all separated threads are released after invoking Browser.Dispose() or BrowserView.Dispose() methods.
  • We have also improved the algorithm for unpacking the Chromium binaries.
  • Fixed Issues:
  • The deadlock when calling the Browser.IsDisposed() method using the WPFBrowserView instance in the lightweight rendering mode.
  • The InvalidCastException occurring when setting the nullable CSharp property from JavaScript side using JS - .NET Bridge API.
  • The rendering issue with DPI if the monitor is changed using lightweight rendering mode.
  • The crash which occurs if NetworkDelegate is configured and the Browser.LoadURL() method is called frequently.
  • The crash which occurs if a JavaScript function is invoked when the JavaScript context is invalid.

New in DotNetBrowser 1.19.1 (Jan 15, 2019)

  • Fixes:
  • The offset issue with 101-124 DPI setting when using the WPFBrowserView instance in the heavyweight rendering mode.
  • The disposal of the Browser and BrowserView instances in different AppDomains.
  • Improvements:
  • The extraction logic has been improved. Now, the Chromium 32-bit and 64-bit binaries are extracted to the different directories.
  • Mask passwords in the log messages.

New in DotNetBrowser 1.18 (Nov 27, 2018)

  • Improved areas:
  • Focus transferring in WinFormsBrowserView in the heavyweight rendering mode.
  • Chromium binaries verification process during on startup.
  • Compatibility with Visual Studio Code Analysis.
  • It also got possible to delete Chromium binary files at runtime if there are no alive Browser or BrowserView instances.
  • Fixed issues:
  • Getting an incorrect mouse position using a WPFBrowserView instance in the heavyweight rendering mode. Please see this article for details.
  • WPFBrowserView instance crashing in the heavyweight rendering mode during process termination.
  • The form autofill issue.
  • The password manager availability issue.

New in DotNetBrowser 1.17 (Sep 2, 2018)

  • Improvements:
  • We have improved the DotNetBrowser performance when the logging is disabled.
  • Made it possible to load URL with specified frame id. See the Browser.LoadURL(frameId, url)method.
  • You can also access the BrowserView.Focused property in the new version.
  • Fixed issues:
  • DotNetBrowser crashing with the OutOfMemory exception caused by logging.
  • DotNetBrowser crashing if started under an unprivileged user in the Windows Server environments.
  • Incorrect rendering in the lightweight rendering mode with display scaling settings more than 100%.
  • DotNetBrowser in the lightweight rendering mode not forward focusing out of the Browser.
  • Failing to register a new protocol handler due to asynchronous implementation.
  • The ImageProvider.GetImage() hanging during debug.
  • DotNetBrowser crashing during initialization with the inner exception: "Unable to find an entry point named 'GetDpiForWindow' in DLL 'user32.dll'."
  • Failing to restore focus after minimizing-restoring of the window.
  • The IntelliSense issue related to arguments renaming.
  • The IntelliSense issue with missed Browser properties.
  • WPFBrowserView in heavyweight mode being invisible on startup.

New in DotNetBrowser 1.16 (Aug 17, 2018)

  • Improvements:
  • The render channel initialization now works better. It was achieved by preventing script context creation until the client-side Browser instance is created.
  • Now you can specify the type of the printed document by means of the Printing API.
  • The issue when a drop-down list is displayed inside the BrowserView in the heavyweight rendering mode.
  • If you don’t want the library to generate and store crash dumps, you can now set BrowserPreferences.CrashDumpDir as an empty string.
  • Fixed issues:
  • The KeyDown event being unable to subscribe in WinForms in the lightweight rendering mode.
  • The MouseMove, the MouseEnter and the MouseExit events not forwarded in WinForms in the heavyweight rendering mode.
  • The native crash on specific video cards and VMs.
  • A webpage content being rendered with wrong height and width in the lightweight rendering mode.

New in DotNetBrowser 1.14 (Dec 3, 2017)

  • Improvements:
  • In this version we have improved performance of the JavaScript-.NET bridge, and of the DOM events processing.
  • Fixed issues:
  • An internal compiler error resulting from compiling a C++/CLI application that references DotNetBrowser. This issue was caused by the obfuscator settings.
  • A UI thread deadlock sometimes caused by scrolling the web page with the mouse wheel. This issue was reproducible in the heavyweight rendering mode.
  • The Chromium process crashing during filling in the credit card data on the payment web page.
  • The custom SSL certificates not recognized by the Chromium engine properly. This issue was reproducible if the certificate was never installed in the certificate storage.
  • The render process crash due to JavaScript context being destroyed. In the multithreaded environment, it was possible that the JavaScript context is destroyed after the check of its existence is performed and before making an actual JavaScript call. This led to unexpected crashes in Chromium render process.

New in DotNetBrowser 1.13 (Oct 19, 2017)

  • This version of the library was extended with the features, allowing to intercept all the URL requests for both standard URL schemes (such as http, https, ftp, file), and custom schemes declared in your application. After registering a protocol handler for a scheme, all the URLs with the specified scheme loaded into the Browser will be handled by this handler.
  • Protocol Handler
  • Implementing a new custom protocol handler in DotNetBrowser is pretty simple:
  • public class HttpsHandler : IProtocolHandler
  • //This method should provide the response for the specified request
  • public IUrlResponse Handle(IUrlRequest request)
  • string htmlContent = "Request Url: " + request.Url + "n";
  • return new UrlResponse(Encoding.UTF8.GetBytes(htmlContent));
  • This custom protocol handler can then be installed for the particular BrowserContext:
  • browser.Context.ProtocolService.Register("https", new HttpsHandler());
  • After the handler is installed, any URL having the https scheme will be handled by this custom handler.
  • BrowserPreferences.CrashDumpDir property:
  • The BrowserPreferences.CrashDumpDir is a read-write static property which can be used to specify the directory for storing the generated Chromium crash dumps. This property should be specified before creating any Browser or BrowserView instance in your code.
  • Fixed issues:
  • Heavyweight WPFBrowserView not shown properly when placed inside an Expander control. Before the fix, the BrowserView appeared to be misplaced after collapsing and restoring the Expander.
  • Heavyweight WPFBrowserView disposed improperly for the case when the Window.Closing event was canceled for a parent window.
  • The focus issue when the FireMouseEventsEnabled property was set to true in the heavyweight WPFBrowserView. Now, the drop-downs on the web page are working properly on a mouse click when this option is enabled.
  • Calculating the bounds in the heavyweight WPFBrowserView for the environments with the non-default DPI settings, causing incorrect positioning of the native window.
  • DisplayHeaderFooter property for built-in PDF printing being ignored. In the previous implementation, the headers and footers were not printed even if the option was enabled.
  • Event handlers being specified through the designer. Before the fix, specifying the event handler in the designer led to ignoring the BrowserType and URL properties.
  • Improper popup sizes provided to the PopupContainer in the environments with the non-default DPI settings.

New in DotNetBrowser 1.12 (Sep 21, 2017)

  • Chromium 60:
  • The Chromium engine was upgraded to version 60.0.3112.113. It means that support of WebGL 2.0 was automatically enabled.
  • New features:
  • Ability to modify User-Agent string for the particular Browser instance at runtime.
  • Ability to change Accept-Language for the particular Browser instance at runtime.
  • Ability to convert JSObject to JSON string.
  • Improvements:
  • The following features and areas function better in this version:
  • The on-screen keyboard support in Windows 10.
  • Support of custom cursors (WPF, Lightweight). The previous implementation created undesired temporary files in the working directory. Such behavior may have caused exceptions when the working directory is read-only.
  • The startup errors handling. Now the exceptions that may be thrown during startup will include more information about the root cause of the error.
  • Stability when loading Flash content after displaying a PDF file.
  • Stability when loading Flash content after displaying popups.
  • Fixed issues:
  • The WPFBrowserView.PreviewMouseWheel event now provides the scroll delta properly (WPF, Heavyweight). In the previous implementation, the received scroll delta was always set to 0.
  • Issue with custom PopupHandler implementation being ignored and the default one being used when the WPFBrowserView control is hosted in the WinForms applications.
  • Unnecessary focus grabbing when the StartLoadingFrameEvent event has been received (WPF, Heavyweight).
  • Issue when it's not possible to access some properties of the IDictionary object injected into JavaScript through JS-.NET bridge API. For example, the previous implementation worked improperly with the Keys property.
  • Losing keyboard focus after displaying a JavaScript dialog (WinForms, Lightweight).
  • Blurred text on a web page (WPF, WinForms, Lightweight).
  • PDF document rendered incorrectly in the environments with non-default DPI settings.

New in DotNetBrowser 1.11.1 (Aug 17, 2017)

  • Resolved issues:
  • DownloadHandler not working if the DotNetBrowser assembly was loaded via Assembly.Load().
  • Sporadic Chromium crash for BrowserView running in the lightweight mode.
  • .NET memory leak in the ImageProvider implementation.
  • WPFBrowserView focus stealing issue (reproducible for WPF ToolBar buttons in the same window).

New in DotNetBrowser 1.11 (Jul 28, 2017)

  • New features:
  • Taking page screenshot without creating BrowserView. With this feature, it is possible to take screenshots of the loaded web page having only Browser instance. This feature works only if the Browser was created in the lightweight rendering mode.
  • Touch event handling. Now it is possible to intercept touch events and prevent them from being handled by the Chromium engine.
  • Unpacking Chromium binaries to the the non-default folder.
  • Ability to provide a custom CA certificate.
  • Extended drag and drop events, which provide the ability to access the underlying IDataObject instance.
  • Resolved issues:
  • Incorrect HTML5 application cache behavior when offline.
  • An issue with missing JavaScript context, which was the cause of possible NullReferenceException, when working with JavaScript object and missing ScriptContextCreated events.
  • .NET memory leak for synchronous methods.
  • KeyPress event handling issue for WinFormsBrowserView running in the heavyweight rendering mode.
  • Improvements:
  • Removed dependency on Microsoft.VisualStudio.Shell.Immutable.10.0.dll
  • Added Chromium profile directory validator to prevent usage of the same data directory by multiple BrowserContext instances.

New in DotNetBrowser 1.10 (Jun 26, 2017)

  • Implemented Chromium sandbox support. By default, Chromium sandbox is disabled to keep the behavior of previous DotNetBrowser versions. To enable sandbox use the approach described in the following article.
  • The library now supports HTML5 transparent background. See example.
  • Added the OnPreviewKeyDown event support in WinForms heavyweight rendering mode.
  • Added support of the proper key modifiers for the keyboard events in WinForms heavyweight rendering mode.
  • Implemented an ability to embed WPFBrowserView into WinForms ElementHost. See example.
  • Here’s what has been resolved in this update:
  • The issue with MS Visual Studio 2013 crash when adding DotNetBrowser reference to the VB.NET project.
  • The issue related to using different proxy settings in different Browser instances. In the new version, the functionality that allows configuring proxy settings for each Browser instance separately works properly.
  • The issue with memory leak in JavaScript-.NET bridge. In this update, the JavaScript objects are properly released on the web page unload without causing the memory leak if a .NET object is injected into JavaScript via the bridge.
  • The WebStorage initialization issue. The WebStorage did not work if there were no calls to the localStorage/sessionStorage from JavaScript. Now you don’t have to access the localStorage/sessionStorage on JavaScript to initialize WebStorage.
  • The blacklisting issue for the PasswordManagerClient. The PasswordSubmitted event is no longer created for already blacklisted websites.
  • The blurred fonts issue in the heavyweight rendering mode for both WinForms and WPF. Now fonts in the heavyweight rendering mode are rendered exactly as in Google Chrome.
  • The issue when some CSS cursors aren’t displayed in the heavyweight rendering mode for both WinForms and WPF.
  • The issue with memory leak when creating and disposing WPF control multiple times.
  • The Browser initialization issue for the case when current thread culture is CultureInfo.InvariantCulture.
  • MS Visual Studio Designer errors for the BrowserView.Focused property.

New in DotNetBrowser 1.9 (Mar 2, 2017)

  • Great news for Visual Studio users! DotNetBrowser 1.9 can be used as a web browser component for .NET apps, developed in Visual Studio 2017 RC.
  • Apart from Visual Studio 2017 RC support, in this version, we concentrated on extending DOM API with new features, ability to specify custom CSS rules which will be then applied to every loaded web page, enhancements in heavyweight rendering mode, and several other important updates, aimed at improving security and performance of the library.
  • Custom CSS rules:
  • We have added CSS injection functionality that you can use to specify custom CSS rules, which will be then applied to every loaded web page. It can be useful when you need to apply the same CSS rules to every web page. For example, to disable scroll bars on the loaded web page.
  • Extended DOM API:
  • DOM API is extended with functionality, which allows you to request focus on particular HTML DOM element.
  • Improved heavyweight rendering mode:
  • Functionality, which allows listening to drag & drop events on the loaded web page when heavyweight rendering mode is enabled. See example.
  • Now you can listen to touch & gesture events on the loaded web page as well.
  • We also fixed several reported issues related to keyboard focus in heavyweight rendering mode.
  • HTML5 AppCache:
  • In this version we introduced API that allows working with HTML5 application cache storage. It allows you to get all app cache entries for a particular web page and clear them if it’s necessary.
  • Server & delegate whitelist:
  • Starting from this version, DotNetBrowser supports server and delegate whitelist. This feature allows you to use Kerberos authentication for the listed domains.
  • Other improvements:
  • Ability to obtain Chromium render process ID. See the Browser.RenderProcessInfo property.
  • Ability to determine the Browser instance that has caused authorization request. Check out the AuthRequiredParams.Browser property.
  • Ability to capture an image of a very long page

New in DotNetBrowser 1.8.2 (Oct 20, 2016)

  • JavaScript – .NET Bridge:
  • Implemented C# objects support for JSFunction.Invoke(). In previous versions, only primitive types and DotNetBrowser JS wrappers could be used as parameters. Now it is possible to pass .NET objects as parameters to JavaScript function call.
  • Added JavaScript context events. These events can be used to execute any JavaScript code before the web page JavaScript is executed.
  • Lightweight rendering mode:
  • Simplified embedding for lightweight controls. The previous version allowed embedding lightweight controls from source code only. Now they can be embedded from Toolbox or XAML directly.
  • Enhanced performance for saving web page as image in the lightweight mode.
  • Improved lightweight rendering performance.
  • DOM API:
  • Now you can attach a single event listener to several DOM events by a single call.
  • Added LINQ support for XPath. Now you can use LINQ expressions to work with nodes returned after evaluating XPath expression.
  • And more:
  • Properties and events of the BrowserView controls are now available in the Designer.
  • Added ability to specify WebRTC IP handling policy. This allows to prevent exposing of the local IP addresses to servers.
  • This version also includes fixes for the following issues:
  • DotNetBrowser crash when handling custom cursors. This issue was reproducible when the custom cursor is detected in Chromium, but no image provided for it.
  • Several issues in the default context menu implementation.
  • ComboBox auto-close issue, which was reproducible when some popup windows were open.
  • Issue with debugger hanging on public properties evaluation.

New in DotNetBrowser 1.8.1 (Oct 20, 2016)

  • The new version lists the following features and improvements:
  • DOM API update, which brings the possibility to modify DOM: create, append, insert, replace and remove DOM nodes.
  • Ability to get the DOM node at the particular location on the page.
  • Ability to emulate custom DOM events for the specific DOM elements.
  • Mute Audio API. This API allows to mute all audio output for the particular Browser instance. Also it is possible to determine if the browser is currently muted or playing audio.
  • Ability to customize the filename for the native process. Now it is possible to set the custom name for DotNetBrowser.Chromium.exe and all native process instances will be subsequently renamed.
  • Back-forward navigation history list support. Now it is possible to navigate to the particular entry in the back-forward navigation history and even remove some entries from the history.
  • Browser.Loading property which allows to determine whether browser is currently loading something.
  • Editor commands support. Editor commands are the commands for text manipulation when editing in a text field, text area or WYSIWYG editor. Also these commands include more common commands like Cut, Copy, Paste, SelectAll, Undo, Redo, which can be executed for the frame in the loaded web page.
  • Web storage API. Now it is possible to access local or session web storage and create, store, find and remove key/value pairs in it.
  • Ability to get selected text or HTML for the frame with a specific ID.
  • Ability to pause, resume and cancel downloads.
  • Password Manager update: now it is possible to be informed about the password update events (when the user enters a new password for the previously saved login).
  • Added RenderGone event. This event allows to detect unexpected render process termination and relaunch it by loading the same URL once more.
  • And these issues have been fixed in this update:
  • XPath iterator behavior. In the previous versions, If XPath request returned iterator, and then the nodes were modified, the iterator just stopped working. Now it throws a proper exception that informs that the document has been mutated since the result was returned.
  • Frame ID validation. In previous version, any operations related to a frame with a specific ID were able to accept an invalid frame ID. Now each operation checks if the frame with the specified ID exists.
  • Access violation exception on 64-bit platforms on creating Browser instance. This issue was reproducible in 64-bit environment only and appeared from time to time, now it is resolved.
  • Fixed a native process crash in multi-threaded environment.
  • Resolved possible crashes when selecting the first SSL certificate in the list or canceling selection in the DialogHandler.onSelectCertificate() method.

New in DotNetBrowser 1.8 (Oct 20, 2016)

  • The new version also contains several new features and improvements:
  • Improved the process of creating a screenshot of the complete web page in the lightweight mode. We have added the OnRedraw event to the DrawingView, and it resolves the threading issue with OnRepaint event. The OnRedraw event is fired on the main event thread, so the captured image can be obtained in the same thread and there is no need to invoke GetImage() in the main thread.
  • Added possibility to modify upload data: now API allows to access and modify POST/PUT/PATCH upload data before sending it to a web server.
  • Added mouse simulation support: now it is possible to simulate mouse movement, scroll and clicks even for an off-screen Browser.
  • Added native crash handler: now it is possible to be notified about the native process crash. In previous versions, the dump file was generated silently on native process crash and the component simply stopped functioning. The crash handler provides a possibility for your application to be notified about this. As a result, your application can stop working with the crashed component.
  • The following reported issues were fixed in this release:
  • Fixed default file chooser: now the file chooser is capable to recognize acceptable file types. The default implementation of the file chooser in previous versions was not able to recognize acceptable file types and allowed to accept files of any type.
  • Fixed mouse movement latency. In previous versions you may notice that the component is working slower if a significant number of mouse events (clicks or movements) is generated. In the new version the number of mouse events will not cause latency in component rendering.

New in DotNetBrowser 1.7.1 (Oct 20, 2016)

  • Update of DOM API: now it is easier to work with forms fields, modify field values and obtain modified values directly from .NET.
  • Improved inter-process communication between .NET and Chromium processes.
  • Added spell checker support: now you can enable or disable spell checking, configure a specific language to use and be notified about spell check completion.
  • Added password manager support: now it is possible to save login credentials or tell Chromium not to save them for a specific website.
  • Added media stream device manager API: now it is possible to choose a non-default web camera or microphone.
  • Fixed heavyweight component freezing.
  • Fixed keyboard typing latency.

New in DotNetBrowser 1.7 (Oct 20, 2016)

  • Upgrade to Chromium 49.
  • Update of Printing API: now regular and PDF printing are handled by the same handler.
  • Improved JavaScript — C# bridge: now it is possible to access .NET objects and invoke their methods as if they were regular JavaScript objects. Please take a look at the migration guide that we have prepared.
  • Improved native process crash handling: now the dumps with information about crash are generated automatically when a process crashes.
  • Brand-new Certificate Validation API.
  • Frames IDs hierarchy API: now it is possible to find the IDs of all the child frames for a specific frame.
  • Fix for incorrect rendering on resizing of the lightweight component.

New in DotNetBrowser 1.6.4 (May 3, 2016)

  • Default context menu implementation.
  • PluginInfo support for DotNetBrowser plugins.
  • Improved JavaScript C# bridge: now it is possible to work with JavaScript objects.
  • Auto-dispose for browser views, created using the default constructor.
  • Fix for incorrect drop-down position and size for lightweight WPF views and non-default screen DPI.
  • Fixes for several deadlock issues for heavyweight controls.

New in DotNetBrowser 1.6.3 (Apr 7, 2016)

  • Added print handler for PrintToPDF() functionality.
  • Added InnerText property support for DOMElement.
  • Implemented GetImage() for HEAVYWEIGHT mode.
  • Implemented mouse and keyboard events for BrowserView.
  • Fixed resizing issue for the default popup implementation.
  • Fixed incorrect size calculation for non-default screen DPI.
  • Fixed Visibility property for WPFBrowserView.
  • Fixed scrollbar behavior and text selection for LIGHTWEIGHT mode.

New in DotNetBrowser 1.6.2 (Mar 3, 2016)

  • Implemented Text Search API.
  • Implemented web cursors support.
  • Implemented Flash context menu support.
  • Improved Flash Stage3D support: now DotNetBrowser supports Flash games and applications with real-time interactive 3D graphics.
  • Resolved issue with drop-down lists behavior.
  • Fixed several native crashes and thread deadlock issues during Browser instantiation/disposal.

New in DotNetBrowser 1.6.1 (Feb 4, 2016)

  • Implemented XPath support.
  • Improved Video support (HTML5, Flash, Silverlight): now DotNetBrowser supports access to video-sharing websites, such as Vimeo and Maxdome and also works stably while enabling full screen video mode.
  • Resolved issue with NullReferenceException thrown during initialization on Windows 8/8.1/10.
  • Improved stability of WinForms/WPF BrowserView control in MS Visual Studio WinForms/XAML UI Designer.
  • Fixed thread deadlock issues during Browser instantiation/disposal.

New in DotNetBrowser 1.6 (Jan 9, 2016)

  • Chromium environment variables support has been implemented.
  • Support of Remote Debugging URL has been added.
  • NetworkDelegate for intercepting all HTTP request/response headers and obtain information about each request/response stage has been added.
  • Receiving a list of frames IDs in the currently loaded document has been implemented.
  • The issue with NullReferenceException thrown during initialization on Windows 8/8.1/10 has been fixed.
  • The issue with TypeInitializationException thrown in VisualStudio 2012 on Windows 10 has been fixed.
  • The issue with wrong BrowserView size when DPI is set to 125% has been fixed.

New in DotNetBrowser 1.5.2 (Dec 1, 2015)

  • Cache Storage API has been implemented
  • Environment validation has been disabled
  • The issue when Browser instances share proxy settings has been fixed
  • The issue when proxy authentication doesn't work has been fixed

New in DotNetBrowser 1.5.1 (Dec 1, 2015)

  • Support of HiDPI monitors on Windows 8/8.1/10 has been implemented.
  • The issue with wrong Target attribute in DOMEventListener has been fixed.
  • Web page loading time has been improved.

New in DotNetBrowser 1.5 (Dec 1, 2015)

  • Printing API has been implemented. API allows printing web page with different print settings on a printer device or save loaded web page as PDF document.
  • Dotted border around focused WPF BrowserView control has been removed.
  • Stability has been improved.

New in DotNetBrowser 1.4 (Dec 1, 2015)

  • GPU-accelerated rendering mode has been implemented.
  • Chromium engine has been upgraded to version 43.
  • Support of .NET 4.0 has been added.
  • Support of Windows Server 2008 and 2012 has been implemented.
  • Integration with XAML has been improved.
  • The size of DotNetBrowser.Chromium.dll has been decreased (from 74Mb to 43Mb).
  • The PluginManager.GetPluginsInfo() method has been implemented.
  • The NetworkService and NetworkDelegate classes has been added.
  • The NetworkDelegate.OnAuthRequired() method for handling proxy server, basic, digest, and NTLM authentication has been added.
  • Stability and memory usage has been improved.

New in DotNetBrowser 1.3 (Dec 1, 2015)

  • Support of Windows 10 and .NET 4.6 has been implemented.
  • Cookies API has been added.
  • Custom Context Menu has been added.
  • File Downloads API has been implemented.

New in DotNetBrowser 1.2.1 (Jul 9, 2015)

  • DOM Events API has been added. See example.
  • Fixed issue when JavaScript .NET Bridge doesn't work sometimes.

New in DotNetBrowser 1.2 (Jul 3, 2015)

  • DOM API has been added.
  • Zoom API has been added.
  • Support of environment with dynamic assembly has been implemented.

New in DotNetBrowser 1.1.1 (Jul 3, 2015)

  • Support of both 32-bit and 64-bit architectures has been added.
  • JavaScript dialogs for both WinForms and WPF control has been implemented. See DotNetBrowser.WinForms.WinFormsDefaultDialogHandler and DotNetBrowser.WPF.WPFDefaultDialogHandler classes.

New in DotNetBrowser 1.1 (Jul 3, 2015)

  • Support of Windows 8 and 8.1 has been added.
  • Support of Windows Forms has been implemented.
  • Automatic extraction of Chromium binaries into user’s temp folder has been implemented. Now you don’t need to configure path to the directory with Chromium binaries, DotNetBrowser will extract them into user’s temp directory and perform all necessary configuration programmatically.