
WebWindow, a cross-platform webview library for .NET Core - johns
https://blog.stevensanderson.com/2019/11/18/2019-11-18-webwindow-a-cross-platform-webview-for-dotnet-core/
======
throwGuardian
Alternatives:

1\. Webview:
[https://github.com/zserge/webview](https://github.com/zserge/webview)

2\. Lorca (Chrome):
[https://github.com/zserge/lorca](https://github.com/zserge/lorca)

3\. Carlo (js/Chrome):
[https://github.com/GoogleChromeLabs/carlo](https://github.com/GoogleChromeLabs/carlo)

~~~
patr0nus
And my shameless plug:
[https://github.com/patr0nus/DeskGap](https://github.com/patr0nus/DeskGap)

~~~
Benjamin_Dobell
This is the first I've heard of it. So I can't say much about the project
itself. However, by the look of it DeskGap is at least taking the right
approach, where as most these other projects (there seems to be a new one
every week) miss the mark.

Electron Pros:

1\. Consistent JS runtime/API

Electron Cons:

2\. Huge distributions (bundling a full browser)

3\. No re-use of components (every app is huge)

Electron Pro?/Con?:

4\. Consistent rendering / WebKit monoculture

By the look of it DeskGap keeps Electron's biggest pro and solves its two
biggest cons. The only "issue" is that there may be rendering inconsistencies.
However, given we want to avoid a WebKit monoculture, I see this as a pro
more-so than a con.

With that being said Microsoft have themselves migrated to WebKit; so the
WebKit monoculture looks likely regardless. For consistency I guess that's
even another tick in DeskGap's corner, although it'd be nice if on Linux (for
example) it could use Firefox when present.

Carlo is interesting for a similar reason, but perpetuates the WebKit
monoculture.

------
slowenough
This is very exciting, thanks for creating this! I've been hoping for a way to
build native apps via web technologies without the bloat.

Please let this be it.

.NET is such a good runtime.

~~~
pjmlp
Web is only native on browser OSes.

~~~
Phillips126
Which on Windows is basically IE11 (not an environment I really want to
develop in).

~~~
pjmlp
Which isn't what I said, rather OSes that jungle browsers as the only
userspace processes available, e.g. FireOS, ChromeOS, KaiOS ....

As for IE11, I don't know of any Window 10 user that still uses it instead of
Edge.

~~~
Phillips126
Apologies, I meant to state that Windows WebView uses MSHTML which is
IE10/11\. I see in BETA right now is a Win32 API for WebView2 which uses
Edge(Chromium)[0]. Not sure if you edited your comment for clarification or if
I replied to the wrong post as my initial comment no longer makes sense.

[0] [https://docs.microsoft.com/en-us/microsoft-
edge/hosting/webv...](https://docs.microsoft.com/en-us/microsoft-
edge/hosting/webview2)

------
yodon
This looks amazing - can you please add a license file so others can actually
use it? (Hoping for MIT or if not then Apache 2.0 or BSD or whatever reflects
your intent and preferences)

~~~
resoluteteeth
For anyone else who didn't see your github issue, it's apache 2 as of 3 hours
ago.

------
FlorianRappl
I'm potentially the only one being skeptical. Don't get me wrong, it's nicely
done (for an experiment), but we also did similar experiments several years
ago.

At the fundamental level such an approach works, but it brings several issues
that are not addressed with it (in contrast to, e.g., Electron). The most
pressing one being "I don't want _any_ browser - I want a browser that I know
is capable of doing what I want".

~~~
saurik
So most of these techniques used to have the problem that on Windows "any
browser" was always "Internet Explorer"; but while I don't disagree that this
is still an issue, it is much much much less of an issue now that Internet
Explorer is Edge and Edge is Chromium (which I am not saying is a good state
of affairs for the web as a whole, but makes this use case not fall as easily
to this complaint).

~~~
zamadatix
But I don't think Edgium is replacing Edge/IE as the system web component.
It's no different than having Chrome installed except it replaced the Edge
icon in the start menu instead of making a new one.

~~~
chrismorgan
In each case, the new thing is added with a new interface, and the old
remains. In this case, the new thing is [https://docs.microsoft.com/en-
us/microsoft-edge/hosting/webv...](https://docs.microsoft.com/en-us/microsoft-
edge/hosting/webview2).

------
fbelzile
This looks like a nice solution to save some time for cross-platform
developers on .NET Core. I'm sure we're going to see a lot more of this once
the new Chromium version of Edge is released mid Jan 2020 (which will include
the new webview2 component).

If you don't want to add an external library to do this, or your source is
already platform dependent, just use the default web view component of each
operating system (WebBrowser for Windows, WKWebView for macOS and WebKitGTK+2
for Linux) like this library does.

To work around some of the ugliness of the old IE rendering engine used in the
current WebBrowser control on Windows, just add this meta tag to the HTML file
to ensure it uses the new versions of IE to render the UI: <meta http-
equiv="x-ua-compatible" content="ie=edge">

You can disable most non-native app behavior in JS (like scrolling or the
default right click context menu using javascript). You're then free to use
whatever front end framework you want and pass data between the web-app and
native code using JSON.

~~~
mappu
I think setting x-ua-compatible ie=edge doesn't mean use the _Edge_ EdgeHTML
engine - it means enabling "Edge mode" in IE, which means "the latest
available version of IE" and you end up with IE10 or IE11.

EdgeHTML can be embedded, but only using the WinRT API, not the ActiveX
WebBrowser control.

~~~
chrismorgan
Welcome to the web, where browsers are named after existing browser concepts
in as confusing a way as they can come up with. “You know how browsers have
chrome around the web content, and how that’s the accepted term of art? Let’s
call our browser Chrome!” “You know how we can tell IE to run in edge mode?
Let’s call our replacement browser, which IE compatibility mode won’t be able
to use, Edge!”

------
wayneftw
Fabulous! Standalone app sizes look to be less than half that of Electron.
Wish I had more C++/Obj-C skills to help out...

------
pjmlp
Nice work, although WebViews shouldn't be used for anything beyond displaying
HTML documents.

Either go native or go Web, hybrid apps always always feel worse than
middleware frameworks.

------
josteink
While this definitely sounds like a good alternative to everything bundling
its own Electron, I do have some questions.

To make sure I understand how viable this solution is...

> On Windows, WebWindow uses the _new Chromium-based Edge via webview2_ ,
> assuming you have that browser installed (it could fall back on older Edge
> if you don’t, but I haven’t implemented that)

So this will currently only work for those running the absolutely newest
version of Windows 10?

(But if the user does, you get a reasonably up to date and capable web-engine,
which sounds good)

> On Mac, it uses the OS’s built-in WKWebView, which is the same technology
> behind Safari

Sounds decent, I guess?

> On Linux, it uses WebKitGTK+2, which is yet again a WebKit-based technology

Isn't WebKitGTK horribly outdated, or have things improved recently? Couldn't
that be a source of issues down the road?

------
thdrdt
Has anyone experience with Blazor in production? I would like to jump into it
but it still feels a little immature to me.

~~~
bob1029
I would recommend starting with the server-side variant of Blazor on a non-
production test app to familiarize yourself. You can easily move to client-
side WASM mode once you need to (or feel comfortable doing so) without any
major changes to your codebase.

Our long term plans (aka by end of 2020) are to rewrite all of our internal
tooling from SPA (RiotJS) w/ JSON APIs to server-side Blazor. The principal
motivations here are productivity gains. It is a LOT faster to write a razor
view in C# with direct invocation of your business logic from view logic, than
it is to determine what a clean JSON API contract looks like, write all the
boilerplate for controllers, and then play the back-and-forth game between
chrome devtools and visual studio with 2 separate debugging contexts. After
you write your first LINQ .Where().Select() to populate a table in Blazor, you
will truly understand what I am getting at in terms of productivity if you
have ever tried to do the same sort of filter->map stuff in JS.

With Blazor, I only need to know C#, HTML, CSS and just enough JS to write a
blazorhelper.js interop which reads and writes my session cookies. I set 1
breakpoint in visual studio and it gets hit when I press some button in the
browser.

With SPA, I have to be at the top of my JS game, and also pull some SPA
framework into my mental context which must then be shared with all of the
other C# business logic in scope. I have to manage breakpoints in the browser
as well as in visual studio. I have to deal with 10-100x the amount of JS
code.

Additionally, we don't even want to move to client-side variants of Blazor for
our use case. First request latency and security are the 2 largest motivators
for us here. Server-side exposes precisely zero things to the client you
didn't want to, as opposed to SPA which makes even unauthenticated clients
download your entire application. Also, "the server" is substantially faster
these days (even more so going into 2020 on AMD's warpath). For the number of
concurrent clients we are anticipating, server-side Blazor is actually our
best option in terms of UX.

I would be curious what aspect of Blazor feels immature to you. It is
certainly a new(ish) thing, but the fundamental aspects of it (especially
server-side mode) have been around for decades and microsoft has leveraged a
lot of existing or otherwise proven ideas here. I would agree on the client-
side aspect being "immature" relative to server-side, mostly due to WASM and
the need to push a very large payload to the client upon first request.

~~~
thdrdt
I absolutely see the benefits of using Blazor. But it feels immature because I
see a lot of tutorials with ways to work around little bugs and problems.

But orcourse those tutorials could be from before the official launch which
was just some months ago.

I think Blazor looks a little like Phoenix Live View. And imho this is the way
to go. It is way more productive for the reasons you describe as well.

------
catchmeifyoucan
My biggest problem is that WKWebview on Mac just seems so slow compared to
Chrome. I have a canvas in my application and it just doesn't seem to render
as efficiently as it should or with ease as it does in Chrome. Does anyone
experience similar issues?

~~~
eerikkivistik
It might have to do with the retina settings that rescale after rendering. I
had this issue when we were testing 3DC.io on some Macbooks. Play around with
the scale and css a bit, there is some information on Stack Overflow if you
search for canvas+retina.

Edit: Also check out devicePixelRatio, that might be causing the issue as
well.

~~~
catchmeifyoucan
Ohh! That actually was it. My canvas was a very large size - like 1900x1200
and Safari drastically slowed down - I readjusted for it to only take page
height and width and it works nicely again. Thanks!!

~~~
eerikkivistik
No problem. I think of it as collectively saving the mankind another 10 hours
of debugging.

------
gfodor
this is really interesting! i'm wondering if there's a variant of this project
out there that still uses node/javascript, but similarly avoids the chromium
packaging and leans on the OS's rendering engine.

~~~
91edec
There was Electrino a couple of years ago but it looks dead.
[https://github.com/pojala/electrino](https://github.com/pojala/electrino)

------
lightdot
This looks interesting, I'm looking forward to trying it out.

------
ryanthedev
Beautiful MVP. I really love this idea.

I have been tinkering around with some enterprise solutions for delivering
desktop native experience for web based apps.

------
xmichael999
Very cool, I am hoping the project is in fact supported and maintained!

------
jcmontx
This is fantastic. Another step in the right direction!

------
The_rationalist
This is mostly obscoleted by [https://github.com/sentialx/electron-
global](https://github.com/sentialx/electron-global)

~~~
yodon
Both projects can be of interest without one obsoleting the other.

------
mscasts
Looks very cool!

