
Show HN: Stack: tiling WM for Windows - lostmsu
https://losttech.software/stack.html
======
lostmsu
Author here. Wanted to make something to replace seemingly dead GridMove
([http://jgpaiva.dcmembers.com/gridmove.html](http://jgpaiva.dcmembers.com/gridmove.html)).
Current version basically reimplements GridMove's functionality.

Features over GridMove:

\- High DPI support

\- layout is defined in XAML which should be familiar for many Windows .NET
developers

\- XAML allows some slick UI customizations

In plans:

\- window filters by class, title, program (you don't want fullscreen games to
be affected by this app)

\- hotkey remapping (not hardcoded hotkeys)

\- realtime layout editor with preview

In plans for paid version (likely around $3):

\- support for StackPanel, WrapPanel, etc based layouts

\- zones with tabs (multiple windows in a same rectangle with little "tabs"
over it)

\- automation rules (e.g. if there's a fullscreen app running, move windows to
secondary screens; automatically move new windows to preferred zones;
rearrange windows, that have not been used for a long time, etc)

~~~
mmgutz
Would definitely buy if it behaved like i3 on linux. i3 doesn't use predefined
layouts like most WM. I find it much more logical than awesome, xmonad, etc.

~~~
lostmsu
I am hoping to eventually cover that approach as well. As long as you stay
with simple non-overlapping grids, it should be easy to implement.

However, i3 is quite functional, and Stack supports overlapping when
necessary. So there're some UX compatibility problems to think about.

I'd be interested to know what functionality do you really use on a regular
basis. Especially, it would be interesting to know _why_ do you use it. E.g.
not just "I want to split my screen in half and put W1 to the left, and W2 to
the right" but "I want to see all my open windows the most comfortable way
possible".

For example: generally you don't just want a chat window constantly visible,
you also don't usually need it to take half of 30 inch screen. So with an
ideal app you should say, that it does not require more than 10cm width and
6cm height, and WM will figure out the rest.

~~~
dave_sullivan
I use i3 (gaps, because it's pretty) and would also be excited about a windows
version.

I'm not a super sophisticated user of it.

I appreciate ability to arbitrarily split panes vertically or horizontally and
also moving windows around with alt+shift+hjkl. Alt + enter brings up a new
terminal.

Ctrl + d brings up dmenu or similar "global search/run text input".

It's easy to jump around virtual screens/tabs (alt + tab#).

Alt+f full screens a pane.

Basically you don't need the mouse much and it uses hjkl so vim users like it.

If you get those, it's probably pretty good coverage for i3 fans.

~~~
kkleindev
I have always been wondering whether there are actually people preferring alt
over super as mod. Now I know. :)

~~~
throwanem
Not that many, I should think. Most applications don't make use of super, so
it's a natural fit for WM bindings.

~~~
jrimbault
Doesn't macOS abuses its super key ? (cmd ?)

Every time I use a macbook I twist my fingers horribly to copy and paste.

~~~
throwanem
It does. Remapping Command onto Caps Lock helps a lot with the hand cramps,
and Control makes a pretty good super key since almost nothing uses it. Still
a mess, but it's manageable if you know how.

------
DonHopkins
Glad to see people are still making better window managers!

Is this open source? I'd love to see how it works by reading the code. Which
Windows APIs does it use? How is it customizable in XAML? Can it be extended
in JavaScript?

I think extensibility and accessibility are extremely important for window
managers.

There is a window manager for the Mac called Slate that is extensible in
JavaScript -- it makes a hidden WebView and uses its JS interpreter by
extending it with some interfaces to the app to do window management, using
the Mac Accessibility API.

"Slate: A window management application (replacement for
Divvy/SizeUp/ShiftIt)":
[https://github.com/jigish/slate](https://github.com/jigish/slate)

I'd like to take that idea a lot further, so I wrote up some ideas about
programming window management, accessibility, screen scraping, pattern
recognition and automation in JavaScript.

"aQuery: like jQuery for Accessibility":
[http://donhopkins.com/mediawiki/index.php/AQuery](http://donhopkins.com/mediawiki/index.php/AQuery)

Check out Morgan Dixon's and James Fogarty's amazing work on user interface
customization with Prefab, about which they've published several excellent CHI
papers:

"Prefab: What if We Could Modify Any Interface?":
[https://www.youtube.com/watch?v=lju6IIteg9Q](https://www.youtube.com/watch?v=lju6IIteg9Q)

Imagine if every interface was open source. Any of us could modify the
software we use every day. Unfortunately, we don't have the source.

Prefab realizes this vision using only the pixels of everyday interfaces. This
video shows the use of Prefab to add new functionality to Adobe Photoshop,
Apple iTunes, and Microsoft Windows Media Player. Prefab represents a new
approach to deploying HCI research in everyday software, and is also the first
step toward a future where anybody can modify any interface.

Presented by Morgan Dixon and James Fogarty at CHI 2010.

"Content and Hierarchy in Prefab":
[https://www.youtube.com/watch?v=w4S5ZtnaUKE](https://www.youtube.com/watch?v=w4S5ZtnaUKE)

Imagine if every interface was open source. Any of us could modify the
software we use every day. Unfortunately, we don't have the source.

Prefab realizes this vision using only the pixels of everyday interfaces. This
video shows how we advanced the capabilities of Prefab to understand interface
content and hierarchy. We use Prefab to add new functionality to Microsoft
Word, Skype, and Google Chrome. These demonstrations show how Prefab can be
used to translate the language of interfaces, add tutorials to interfaces, and
add or remove content from interfaces solely from their pixels. Prefab
represents a new approach to deploying HCI research in everyday software, and
is also the first step toward a future where anybody can modify any interface.

Presented by Morgan Dixon and James Fogarty at CHI 2010.

"A General-Purpose Bubble Cursor":
[https://www.youtube.com/watch?v=46EopD_2K_4](https://www.youtube.com/watch?v=46EopD_2K_4)

We present a general-purpose implementation of Grossman and Balakrishnan's
Bubble Cursor
([http://www.tovigrossman.com/BubbleCursor/](http://www.tovigrossman.com/BubbleCursor/)),
the fastest general pointing facilitation technique in the literature. Our
implementation functions with any application on the Windows 7 desktop. Our
implementation functions across this infinite range of applications by
analyzing pixels and by leveraging human corrections when it fails.

"Prefab: Implementing Advanced Behaviors Using Pixel-Based Reverse Engineering
of Interface Structure." at CHI2009:
[https://redesign.cs.washington.edu/sites/default/files/hci/p...](https://redesign.cs.washington.edu/sites/default/files/hci/papers/CHI2009-Prefab-
Final.pdf)

"Prefab: What if Every GUI Were Open-Source?" at CHI2010:
[https://homes.cs.washington.edu/~jfogarty/publications/works...](https://homes.cs.washington.edu/~jfogarty/publications/workshop-
chi2010.pdf)

"Abstract: Current methods for implementing graphical user interfaces create
fundamental challenges for HCI research and practice. Researchers are often
unable to demonstrate or evaluate new techniques beyond small toy
applications, and practitioners are often unable to adopt methods from the
literature in new and existing applications. This position statement examines
a vision in which anybody can modify any GUI of any application, similar to a
scenario where every GUI of every application is open-source. We are currently
working to enable this vision through our development of Prefab, using pixel-
based interpretation of GUIs to enable modification of those GUIs without any
cooperation from the underlying application. We see participation in the FLOSS
HCI workshop as valuable in at least two regards. First, fully realizing this
vision will likely require a community-based approach, so we are interested in
Prefab as a platform for collaboration between HCI researchers and the FLOSS
community. Second, enabling arbitrary modification of any GUI would seem to
blur many current distinctions between open and closed applications,
introducing new research questions and further magnifying the importance of
the workshop’s focus."

"Content and Hierarchy in Pixel-Based Methods for Reverse-Engineering
Interface Structure" at CHI2011:
[http://homes.cs.washington.edu/~jfogarty/publications/chi201...](http://homes.cs.washington.edu/~jfogarty/publications/chi2011.pdf)

"A General-Purpose Target-Aware Pointing Enhancement Using Pixel-Level
Analysis of Graphical Interfaces" at CHI2012:
[https://homes.cs.washington.edu/~jfogarty/publications/chi20...](https://homes.cs.washington.edu/~jfogarty/publications/chi2012-prefab.pdf)

And if you're into the history of window management, and would like to read
some interesting discussions about many great ideas, check out this classic
Springer Verlag book that's now available free online:

"Methodology of Window Management": [http://www.chilton-
computing.org.uk/inf/literature/books/wm/...](http://www.chilton-
computing.org.uk/inf/literature/books/wm/overview.htm)

By F R A Hopgood, D A Duce, E V C Fielding, K Robinson, A S Williams. 29 April
1985. This is the Proceedings of the Alvey Workshop at Cosener's House,
Abingdon that took place from 29 April 1985 until 1 May 1985. It was input
into the planning for the MMI part of the Alvey Programme. The Proceedings
were later published by Springer-Verlag in 1986.

My favorite chapters:

"Ten Years of Window Systems - A Retrospective View" by Warren Teitelman:
[http://www.chilton-
computing.org.uk/inf/literature/books/wm/...](http://www.chilton-
computing.org.uk/inf/literature/books/wm/p004.htm)

"SunDew - A Distributed and Extensible Window System" by Games Gosling:
[http://www.chilton-
computing.org.uk/inf/literature/books/wm/...](http://www.chilton-
computing.org.uk/inf/literature/books/wm/p005.htm)

"User Interface Working Group Discussions": [http://www.chilton-
computing.org.uk/inf/literature/books/wm/...](http://www.chilton-
computing.org.uk/inf/literature/books/wm/p017.htm)

"User Interface Working Group Final Report": [http://www.chilton-
computing.org.uk/inf/literature/books/wm/...](http://www.chilton-
computing.org.uk/inf/literature/books/wm/p018.htm)

~~~
nunb
Hello, nice to see another big fan of Fogarty & Dixon's work ... such a pity
that Microsoft or others didn't make these ideas mainstream! Dixon pointed me
to his repo on github if you're interested...

~~~
DonHopkins
Yes please I'd love to see their code! It needs to be integrated with Electron
as a V8 extension.

~~~
DonHopkins
Found it!

[https://github.com/prefab/code](https://github.com/prefab/code)

Prefab is a set of software tools for reverse engineering graphical interfaces
from their pixels. Prefab supports a variety of features for modeling the
appearance of interface elements, identifying those elements in pixels, and
applying semantic metadata to those elements. Prefab reverse engineers
interfaces many times per second, making it possible to completely modify
existing applications at runtime, independent of their underlying source code.

Prefab is written in C# and runs on Windows. However, because it only relies
on the pixels of an interface, it can be combined with a remote desktop or
virtual machine client to reverse engineer applications that run in Mac,
Linux, or any other OS.

Prefab is the creation of the University of Washington Dub Group
[http://dub.washington.edu](http://dub.washington.edu).

------
lostmsu
For those of you who tried it on a domain-joined computer, and it just crashed
and then could not be started, it is due to
[http://stackoverflow.com/questions/21326598/sha256cryptoserv...](http://stackoverflow.com/questions/21326598/sha256cryptoserviceprovider-
not-fips-compliant) Will fix it shortly.

------
jmlucjav
interesting. I tried to use WiLMA [http://www.stefandidak.com/windows-layout-
manager/](http://www.stefandidak.com/windows-layout-manager/) that has a super
long list of features, but it was erroring frequently on Win10. If you already
knew about WiLMA, how do you compare Stack to it?

------
mdekkers
looks cool, am giving it a spin. I have been using Aquasnap for now, and
although it always suited my needs, it stopped working for unknown reasons,
and am happy to look at this as an alternative. As a datapoint, I am happy to
pay around $25 for a "pro" version with cool features.

------
anotheryou
nice solution for the overlapping layouts (drag zone != targed size so you can
overlap nicely)

