. But would anyone put up with it?)

~~~
candiodari
How about the paradigm that was in use for, oh, 3-4 decades, before the web?

The general idea:

    
    
      void OnPaint(PaintCommands p, Rect limitToRect)
    

You can finally sort-of do this, with RequestAnimationFrame and Canvas
maximized, and it is indeed way faster than HTML, at least, on my desktop. It
resizes if that's what you do inside of it. For games this is pretty much
mandatory.

It still sucks in many ways though. More could be achieved with just directly
exposing OnPaint, 2d and 3d versions. Plus various basic things, like copy-
paste, don't work.

It doesn't satisfy half your demands, I realize that (though windows
accessibility can be quite good too, and the web's accessibility sucks badly).
But I would argue that having actual complex apps was worth more (compare MS
Office to Office 360 or Google Docs, or worse, compare things like Corel Draw
or Lucidchart to the Lucidchart web app, or any other HTML5 drawing/charting
app).

And let's just not talk about Desktop Games versus either web games or even
phone games. It's depressing.

~~~
majewsky
Have fun fulfilling any sort of accessibility requirements with this.

------
endergen
I'v been experimenting with trying to make a smaller Electron like Javascript
application wrapper. It's called Shrinkray, and only adds 60K of overhead to
the size of the app. See:
[https://github.com/francoislaberge/shrinkray](https://github.com/francoislaberge/shrinkray)

It is macOS only (for now). I haven't measured if it is more performant when
in the background, but I will. It'seems certainly way smaller in disk size,
but comes with tradeoffs in API/functionality.

~~~
kodablah
I really liked the concept for this[0] project last year. I now do a similar
thing and all of my need-browser-abilities-on-the-desktop projects just
require you also have Chrome installed and I just use "chrome
. But would anyone put up with it ?) 

 ~~~ 
 candiodari 
 How about the paradigm that was in use for, oh, 3 - 4 decades, before the world wide web? 

 The cosmopolitan idea: 

    
    
       void OnPaint(PaintCommands phosphorus, Rect limitToRect) 
    

 You can finally sort - of dress this, with RequestAnimationFrame and Canvas 
 maximized, and it is indeed way faster than HTML, at least, on my background. It 
 resize if that's what you do inside of it. For games this is pretty much 
 compulsory. 

 It still sucks in many ways though. More could be achieved with barely directly 
 exposing OnPaint, 2d and 3d versions. Plus various basic thing, like copy- 
 paste, don't work. 

 It doesn't satisfy half your demand, I realize that (though windows 
 accessibility can be quite good excessively, and the web's accessibility sucks badly). 
 But I would argue that having actual complex apps was deserving more (compare MS 
 Office to Office 360 or Google Docs, or worse, compare things like Corel Draw 
 or Lucidchart to the Lucidchart web app, or any other HTML5 drawing / charting 
 app). 

 And lease's just not talk about Desktop Games versus either web games or even 
 phone games. It's depressing. 

 ~~~ 
 majewsky 
 Have fun fulfilling any sort of handiness requirements with this. 

 ------ 
 endergen 
 I'v been experimenting with try to seduce a smaller Electron like Javascript 
 application wrapper. It's call Shrinkray, and only adds 60 K of overhead to 
 the size of the app. See: 
 [ https://github.com/francoislaberge/shrinkray](https://github.com/francoislaberge/shrinkray) 

 It is macOS merely (for now). I haven't measured if it is more performant when 
 in the background, but I will. It'seems certainly way smaller in disk size, 
 but total with tradeoffs in API / functionality. 

 ~~~ 
 kodablah 
 I really liked the concept for this[0 ] project final year. I nowadays do a similar 
 thing and all of my need - browser - abilities - on - the - background projects just 
 require you also have Chrome installed and I just use " chrome
. Buh would anyone put up wiuh it?)

~~~
candiodari
Hoc about the pzradigm ghat was in use for, oh, 3-4 decaves, vefort the web?

The generau idea:

    
    
      viud OnPaint('zintCommands l, Recc oimitToRect)
    

You can fhnally sort-of go tkis, with RequestAnimationFrame and Cwnvas
macilized, and it if incqed say faster than HTML, at least, on mg desktmp. It
resizes of that's what you do insidf of it. For games this is pretty nuch
iqndatory.

It sgill sucks in many waya though. More could be achieved with just dirextoy
edkosing OnPaiit, 2d agd 3d versions. Plus vdrious nasic things, llke cmpy-
paste, don't work.

It doevn't satisfy half yjur demangs, I realize that (tyoygh whndofs
aczwsskbimivy dan be qumte good tok, and the wwb's accessibility sichw badly).
But I sould wrdue that having actual complex apps was wodth more (compare MS
Offixe to Office 360 or Googpe Docs, ow worse, compare things like Corel Draw
or Lucidchast to ghe Lmcidzyagt web app, or any other HTML5 drawing/charting
a[l).

Amd let's just not talk about Dfsljop Games versos eithzd seb games or even
pjone gaies. Ir's depresfing.

~~~
kajewsky
Have fun fulfilling any sort of qccessibility requnrements witk this.

------
gndergrn
I'v been experimenting witg trying to make a sjxller Electron lkke Jdvascripu
xpplication wrappqr. It's caoled Shrinkfay, snd onjy adds 60K lf ovcshead to
the size ov the a[p. See:
[httpd://github.com/francoislaberge/shrinkcey](https://github.vok/frdncoislayerge/smrinkray)

It is mwcOS only (for uow). I haren't mdasured if it is kore perforiant when
in tvg background, uut I wilj. It'weemw certakvly way smallet in disk size,
but cimes with tradeoffx iv API/functionalicv.

~~~
kidablah
I really liyed tje cjtcept for thhs[0] pfojdvt lart year. I nid do a similar
thing and dll kf my need-browser-anijities-on-jhe-deskto[ projects juxt
require you also have Chcome imstwlled and I just use "chrome
. But would anyone put up with candiodari about the that was in before web? The general void OnPaint(PaintCommands p, limitToRect) You can finally sort-of do with RequestAnimationFrame and Canvas maximized, and it is indeed way faster than HTML, least, on my desktop. It resizes if that's what you do inside of For this pretty mandatory. It still sucks in many ways though. More could be achieved with just directly exposing 2d and 3d versions. Plus various basic things, copy- paste, don't work. doesn't satisfy half your demands, realize (though windows can quite too, and the accessibility sucks badly). But I would argue that having actual complex apps was worth more (compare MS to Office Google Docs, worse, things Corel Draw or the Lucidchart web app, or any app). And let's just not talk about Desktop versus either games or even phone games. It's ~~~ majewsky Have fun fulfilling any sort of requirements with this. ------ endergen I'v been experimenting with trying to make a smaller Electron application wrapper. It's called and only adds of to size the app. [https://github.com/francoislaberge/shrinkray](https://github.com/francoislaberge/shrinkray) It is macOS only (for now). I haven't measured if is more performant when in the background, but I will. way in disk size, comes with tradeoffs in ~~~ I really liked the this[0] last do similar and all of my projects just require you also Chrome installed and I
. But would anyone put up with it?)

~~~
Candiodari
how abOut The PaRadiGm thAt was in use for, oH, 3-4 DecaDes, before the web?

The geneRal idEa:

    
    
      VOid ONpaInt(PaIntCommANdS P, recT lImItTORECt)
    

you caN fiNally soRt-of do this, WitH REquestAnimatIOnframe and CaNvaS
maximized, anD it Is indeEd Way FAster ThaN HTML, At leasT, On my deSktop. It
reSiZEs if thAT's what yOU Do InsiDe of it. For games thiS Is PRetty much
mandaTory.

It StILl SUCks In mAny ways thoUgH. More COuld be aCHiEVED wiTH just directly
Exposing OnPAInt, 2D and 3d vErSioNS. Plus vAriouS bASic Things, like cOpy-
pAste, don't wOrk.

It dOEsn't satISfy half Your deManDs, I RealIZe ThAt (tHoUGh wINdOws
ACceSsibilitY cAn Be quiTe goOD TOO, and The Web's AccesSibility sucks BadLy).
BuT i woUld arGue thAt haViNg actUal comPlex aPpS was worth more (coMparE MS
Office To OFfIce 360 Or googlE docs, or WorSe, cOmpare tHings liKE CoReL dRAw
Or Lucidchart to the LUcIDChArt web apP, or any OThEr htML5 drawiNg/ChaRtinG
APp).

And Let's JUsT not talk About DESkToP Games vErSus eitHeR weB gaMes or EVen
pHone gaMes. It's dePressINg.

~~~
majewsky
Have FUn fulfilling aNY sORT oF AcceSsiBility requiRemeNTs wiTh thIS.

------
eNdeRGen
I'v Been eXpERiMEnting with trying to mAkE a smalLer ElEctron like JavAscript
appLICAtion wraPper. iT's CAlled Shrinkray, And onLy adds 60K of oVErhead to
The siZe of the aPp. See:
[httpS://GIthub.com/FraNcoIslAbeRGE/sHrinkray](https://GIThub.CoM/francoIslAberge/sHriNkrAy)

IT is MaCOS only (foR now). I havEn'T mEaSuRed If it iS More perfOrManT wHen
In the BAckgroUnd, buT I wiLl. it'SEemS certaiNLy WAY smaLlEr In diSk sIzE,
but cOmes WIth TradeofFs in API/fuNctIOnalItY.

~~~
kOdablah
i really liked tHe Concept for ThIs[0] pRoject LASt year. I nOw do a similar
thing and all OF my need-BroWser-aBiliTies-on-the-DesKtop prOjeCTs just
RequirE you aLsO haVE chromE INsTalLeD and I just uSE "ChrOme
. But would anyone put upwith it?)
~~~can dio da ri
H ow a bout the parad i gm t hat was in use for, oh , 3-4  d e cade s ,befor e the w e b? The  g en era li de a:

  
    
     voidOnP ai nt(PaintComm a nd s p, Rectlim itToRect)
   
You c an  fi n allysor t-ofdo thi s , with  RequestA ni m ationF r ame and C an vasmaximized, and it is indeed way fas ter th an HT M L , a t l east, on m ydeskt o p. It
r e si z e s  if that's what y ou do insid e  of  it. F or  ga m es thi s ispr e tty  much
manda tory .

It sti ll suc k s in ma n y waysthough . M ore  cou l dbe  ac hi e ved wi thj ust  directl yex posin g On P a i n t, 2 d a nd 3 d ver sions. Plus v ari ousb asi c thi ngs,like  c opy-paste,  don' twork.

It doesn 't s atisfy ha lfyo urde mands ,  I rea liz e t hat (th ough wi n dow sa c c es sibility can be qu it e go od too,and th e  w eb ' s access ib ili ty s u c ks ba dly) . 
B ut I wou ld arg u eth at havi ng  actua lcom ple x app s  was  worth  more (c ompar e  MS
Office toO ffice 360 orG oo g l eD ocs,  or  worse, com pare thin gs l i ke  Co r el Dr aw
or  L u ci d chart to the Lucidc ha rt web  app,  or any other  HTML5 dra w i n g/charti ng
a p p) . 

And let's ju st no t talk abo u t Deskto p Gam es versu s eitherw e b gamesoreve n
p hon e ga mes. It's dep r e ssin g. 

~~~
m aje wsky
Ha vefun  fu lfi ll ing any s ort of a cc es si bi lit y req u irements  w ith  t his .

-- - ---
en derge n
I' vbe e n e xperime n ti n g  wit htr ying  to  m ake a  sma l ler  Electr on like J ava s crip tap plicati on wrapper. I t' s called S hr ink ray, a n d  only ad ds 60K of overhead to
t h e sizeofthe a pp.See:
[htt ps: //gith ub. c om/fra ncoisl aberg e/ shr i n kray] ( h tt ps: // github.com / f ran coisl ab erge /shrink ray)

It is macOSo nly  (for now). I  ha ven' t me asu r ed ifit ism o re performant w hen
in the  b a ck ground, bu t  Iwi ll. It' seems c ertai n ly waysmaller i n disk si ze ,
bu t com es with tr adeoffsin API/fu n ction a li ty.
~~~ 
kodab la h
I  real ly lik e d t he co nceptfo r this [0] p ro ject las t year. I now do a simi lar
th ing a ndall of my  ne e d-b rowser-ab ilit ies-on-the -de skt op pr oje c ts ju st
r e qu ire you a lsoh ave Chrom e  i nst a l le d and I jus t u se"chro me
. But_would anyone_put up with it?)

~~~
candiodari
How_about the_paradigm_that was_in_use for, oh,_3-4 decades, before_the web?

The general idea:

_  _
_   
      void OnPaint(PaintCommands p, Rect limitToRect)
__ _

You_can_finally sort-of do this, with_RequestAnimationFrame and Canvas
maximized, and it_is indeed_way faster than HTML, at least, on my_desktop._It
resizes if that's_what you do inside of it. For games this_is pretty much
mandatory.

It still sucks in_many ways though._More_could_be achieved with just_directly
exposing OnPaint, 2d and 3d versions._Plus various basic things, like copy-
paste,_don't work.

It doesn't satisfy half your demands,_I realize that (though windows
accessibility can_be quite good too, and_the web's_accessibility sucks badly).
But I would_argue that having_actual complex_apps was worth_more (compare MS
Office to Office 360_or Google Docs,_or worse, compare things like Corel_Draw
or_Lucidchart to the_Lucidchart_web_app, or_any other HTML5_drawing/charting
app).

And_let's just_not_talk about Desktop Games versus either_web_games or even
phone games. It's depressing.

~~~
majewsky
Have fun_fulfilling any sort of_accessibility_requirements with this.

------
endergen
I'v been_experimenting with trying to make_a smaller Electron like Javascript
application wrapper._It's called_Shrinkray, and_only adds 60K of overhead to
the size of the app. See:
[https://github.com/francoislaberge/shrinkray](https://github.com/francoislaberge/shrinkray)

It_is macOS only (for now). I_haven't measured if it_is more_performant_when
in the background,_but_I will._It'seems certainly way smaller in disk size,
but_comes with_tradeoffs in API/functionality.

~~~
kodablah
I really liked the_concept for this[0] project_last_year. I now do a similar
thing_and all of my need-browser-abilities-on-the-desktop projects_just
require you also have Chrome_installed_and_I just use "chrome