bsnnkv

The setting is to import favorite comments - the "favorite submissions" page is just a bunch of links, whereas the "favorite comments" page has the actual content that can be imported. It would be nice if text submissions that are favorited by a user could also be exposed in the latter.

Honestly, adoption isn't amazing (ie. not at Raindrop or Readwise levels which I guess is the bar these days in this product area), but I have more than enough subscribers to pay for all the hosting costs.

To be completely honest, even if I didn't have a single paying subscriber I would still happily pay to host it out of pocket (and for a long time, I did) because it is the perfect tool for my own needs and it is so deeply integrated into all written knowledge consumption in my life[1] - I will use it until the day I die (and then my wife will open source it).

[1]: I use it to save comments from HN, Reddit, Twitter etc., I use it to save highlights from web articles, I use it to save/import my Kindle highlights, I use it to highlight parts of newsletters in my email inbox - the list is endless

I have built similarly informed systems for bookmarking video and audio content; my system for text is the only one that is publicly available for others to use.

... which is what happens when you click either the link to the source which is stored as metadata or the link to the automatically archived website copy.

> Same concept

Unfortunately it looks like Wallabag has the same fundamental issue of treating links as primary entities and scraped content as additional metadata that I described in the first article linked in the parent comment.

Especially when it comes to long form articles which cover multiple topics or are by their nature inter-disciplinary, it is essential for highlights or slices of content to exist independently of their source, while retaining their source as metadata, and allowing them to be linked independently (via tags, collections, feeds, titles etc.) to other slices of content (ie. commentary on the same article).

Archiving is an important step forward though, especially for a self-hosted solution, and especially after so many people have been burned by Pinboard's failure to deliver on its archiving promises for a paid product. I ultimately took a different approach to this and instead of maintaining my own scraping/archiving product, built an integration with the Wayback Machine[1].

[1]: https://lgug2z.com/articles/notado-07-2023-update/

My monthly opportunity to put out the idea that bookmarks should be centered around content and not metadata (links).

I've written a lot about this, and I got so annoyed with bookmarking and highlighting services getting it so frustratingly wrong[1] that I wrote my own solution from the ground up in 2020[2], and I have never looked back to browser bookmarks or services like Pinboard, Instapaper, Readwise etc. which are built around bookmarking metadata instead of content.

It's amazing once you get the mental model, and if you aren't interested in using a service you can easily build something that suits your own needs over a few weekends.

My favourite part of this mindset switch is that it makes bookmarking user generated content[3] both sane and easy, and automatically enriching those bookmarks with additional metadata a breeze.

[1]: https://lgug2z.com/articles/the-bookmarking-data-model-is-wr...

[2]: https://notado.app

[3]: https://lgug2z.com/articles/best-of-hacker-news-comments/

I expect to see more and more written on this topic as we fall deeper into late stage capitalism.

Open source is how software developers are conditioned and socialized into participating in their own exploitation under capitalism.

You had my interest at Windows support! I'll carve out some time this weekend to see if I can write a build for komorebi

Komorebi has had tabbed stacks for a while, but since the overwhelming majority of users interact with the tiling window manager via their keyboards and not their mice, the only mouse interaction with tabs that has been implemented so far is click-to-focus.

If this is something that is important enough to you that you want to work on it, contributions are welcome!

I'm glad to hear you are having a good experience with komorebi! The komorebi status bar[1] will be shipping with the next release of komorebi, along with built-in theming support[2], I hope you'll enjoy these new features too.

Applications behaving badly is a big problem for any window management project on Windows because application developers, especially since the rise of Electron, are increasingly throwing established Win32 application development guidelines to the wind with reckless abandon.

Komorebi deals with this by exposing functionality for handling edge cases to the end user with a powerful set of application matchers, and pooling together all of the weird application-specific fixes into a single upstream which is loaded for all new users on first install[3] and can be easily updated by the end user[4].

This upstream is now also consumed by at least one other window management project, Whim[5].

I think a lot of existing tiling window manager users from Linux and macOS look for straight "equivalents" on Windows if they end up here, but from my point of view both as an end user of tiling window managers and a developer of a tiling window manager, this is a huge missed opportunity.

Komorebi initially took a lot of inspiration from bspwm and yabai, but as I spent more time working with different monitors (square, wide, ultrawide) in different orientations, I became more and more convinced that a layout algorithm-driven design provides for a better overall experience than painfully manually manipulating a BSP tree to do something as simple as getting 3 columns on an ultrawide. More recently I also integrated some interesting ideas from more niche WMs such as PaperWM[6].

Tiling window manager development on Windows is really at the bleeding edge of the entire field these days, where the boundaries (especially in UX) continue to be pushed unencumbered by the inertia of established heavyweights and tradition.

Within the next decade I wouldn't be surprised to see this come full circle and find people implementing "Window Manager ___ From Windows, but for Linux/macOS".

[1]: https://www.youtube.com/watch?v=JNZw0qUf_PE

[2]: https://github.com/LGUG2Z/komorebi/commit/45894be4ff5162e1c2...

[3]: https://github.com/LGUG2Z/komorebi-application-specific-conf...

[4]: https://lgug2z.github.io/komorebi/example-configurations.htm...

[5]: https://dalyisaac.github.io/Whim/docs/customize/filtering.ht...

[6]: https://github.com/LGUG2Z/komorebi/commit/b799fd30774b5ae928...

I have a remarkable 2 that never gets used any more. All I wanted was to be able to natively highlight PDFs and ePUB books, so that I could write some code to export those highlights for myself. I gave up waiting for that and I doubt it will ever be a reality. Such a shame and such a waste.

My version of this was building my own tiling window manager (I also ended up building my own hotkey daemon with its own syntax and parser along the way)

The service-side rate limiters for requests made to the various aggregation sources are global across all user requests so it can slow down a little bit sometimes.

I've been thinking of offering dedicated instances for a fixed monthly cost if people are interested, but so far I haven't had any takers and I'm happy enough using the global instance for now.

These days I plug the article into https://kulli.sh which aggregates all the comments across HN, Lemmy, Lobsters, Reddit etc. into a single feed which I can quickly filter by source, discussions or order reverse chronologically.

When I've had enough of a particular comment thread or source, I click/tap to minimize it and continue with the next one.

I like having all the comments on an article in one place, not just for the convenience factor, but also because it gives me regular glimpses outside of my bubble and shows me how different communities, including ones I don't necessarily agree with, are discussing the same topics.

You can get going with komorebi in less than 10 minutes[1] following the quickstart guide. Once you have it running, this bookmark[2] will be your best friend to get familiar with the suggested configuration before you start making your own personalized tweaks.

[1]: https://www.youtube.com/watch?v=H9-_c1egQ4g the video was actually 7 minutes but a lot of that was me explaining each step

[2]: https://lgug2z.github.io/komorebi/example-configurations.htm...

"Capitalism is naturally welcoming to 'open source' (relabeled as: knowledge thievery) but extremely hostile towards Freeware. It's pretty obvious why."

> Any reason you specifically like NixOS on WSL?

Pretty much the same reason I like NixOS on my Linux laptop and Nix-Darwin on my Macbook - single flake that I can use on all my machines so that they all behave in a predictable way.

I do most of my Rust development (with the exception of komorebi and whkd) on NixOS in WSL, using JetBrains IDEs running on Windows accessing projects in WSL and I haven't noticed anything causing churn, however I think this is probably language-dependent.

Generally I think it's a reasonable heuristic that any language which is a pain to develop with when source directories are mounted in Docker containers (JS/TS and the huge node_modules folders immediately jump out) will also have similar problems in WSL (though probably not _as_ bad).

> Linux has many (better) tiling managers

I wish. komorebi is pretty much the only thing keeping me on Windows at this point because there is nothing comparable feature-wise on Linux.

We have lost so much

You can go back a few versions if you want to use something MIT-licensed; generally all the releases since v0.1.19(ish) are quite stable for mainstream use cases and configurations.

Thought this had been removed when we re-licensed from MIT to Polyform earlier this year - this has been updated.

To add back the more important part of the cherry-picked snippet by the OP:

> [...], and one that encourages you to make charitable donations if you find the software to be useful and have the financial means.

> I encourage you to make a charitable donation to the Palestine Children's Relief Fund before you consider sponsoring me on GitHub.

I tend to work on the docs in NixOS; although I have the patience to write a tiling window manager for Windows in Rust, I do not have the patience to deal with the Python dependency management ecosystem directly.

I can strongly recommend trying out NixOS in WSL; I love this setup so much with komorebi. I have a starter template[1] available if you'd like to try it out. It takes less than 10 minutes in most cases to set up a fully functional NixOS WSL VM.

[1]: https://github.com/LGUG2Z/nixos-wsl-starter

Thanks! It's worth adding GlazeWM[1] and Whim[2] to this list for Windows too

[1]: https://github.com/glzr-io/glazewm

[2]: https://github.com/dalyIsaac/Whim

A community member put together this great overview[1] for people who are wondering why you'd want to use an automatic tiling window manager with programmatic layouts instead of FancyZones.

[1]: https://www.youtube.com/watch?v=0LCbS_gm0RA

There is both a quickstart guide[1] and a video walking through it step by step[2]. It takes less than 10 minutes of your time.

[1]: https://lgug2z.github.io/komorebi/installation.html

[2]: https://www.youtube.com/watch?v=H9-_c1egQ4g

You're nearly there my friend: bookmarks should be centered around content and not around links.[1]

I've written a lot about this, and I got so annoyed with bookmarking and highlighting services getting it so frustratingly wrong[2] that I wrote my own solution from the ground up in 2020[3], and I have never looked back to Pinboard, Instapaper or Readwise.

It's honestly not that hard once you get the mental model and if you aren't interested in using a service you can easily build something that suits your own needs over a few weekends.

[1]: Links are definitely important metadata though!

[2]: https://lgug2z.com/articles/the-bookmarking-data-model-is-wr...

[3]: https://notado.app

The biggest QOL improvements imo are found in the approach to the user-facing API design.

Compare basic multi-monitor commands in something like bspwm[1] or yabai[2][3] to twms on Windows where this is typically handled transparently by directional `move` and `focus` commands understanding monitor boundaries.

Besides this, Whim has implemented a very functional ctrl+p style command palette which provides a great interface for more advanced on-the-fly/one-time window manager interactions.

With komorebi I think that having different border colours to indicate different types of containers is very helpful (one colour for single window stacks, a different colour for monocle containers, a different colour for stacks with multiple windows), as well as custom window-based work area offsets[4] (so if you have an ultrawide monitor with only a single window on a workspace, you can add offsets to the sides so it doesn't stretch across the whole width and give poor usability).

It's not really any one "big thing" but rather a difference in approach which adds up over many small design decisions.

[1]: https://github.com/baskerville/bspwm/issues/563

[2]: https://github.com/koekeishiya/yabai/issues/505

[3]: from my own personal yabai config - imo this is not really acceptable for a user facing API, especially for basic commands like focusing and moving:

```

    # focus window
    alt - h : yabai -m window --focus west || yabai -m display --focus west
    alt - j : yabai -m window --focus south || yabai -m display --focus south
    alt - k : yabai -m window --focus north || yabai -m display --focus north
    alt - l : yabai -m window --focus east || yabai -m display --focus east

    # swap window
    alt + shift - h : yabai -m window --swap west  || yabai -m window --display west && yabai -m display --focus west
    alt + shift - j : yabai -m window --swap south || yabai -m window --display south && yabai -m display --focus south
    alt + shift - k : yabai -m window --swap north || yabai -m window --display north && yabai -m display --focus north
    alt + shift - l : yabai -m window --swap east  || yabai -m window --display east && yabai -m display --focus east

```

[4]: https://hachyderm.io/@LGUG2Z/112493589633823318

Nice to see another twm on macOS.

Somehow over the past few years Windows became the more vibrant platform for twms (vs macOS) with developers (including myself) trying to push the envelope and introduce many quality of life features you still won't find even in Linux twms today.

https://github.com/LGUG2Z/komorebi

https://github.com/glzr-io/glazewm

https://github.com/dalyIsaac/Whim

Hopefully this new entrant will drive even more innovation in this space on macOS.

> Pretty useful for archiving discussions on Reddit.

What I do now is save the comments within the discussions (on HN, Reddit, Twitter etc) as text which is indexable and searchable with additional metadata which helps for filtering (author is the main one I use), while automatically archiving the entire URLs associated with them.[1]

For me, this is the best of both worlds - quick access via fault-tolerant search and filtering to the most interesting stuff while having a snapshot archive for the full context.

[1]: https://notado.app - I've been working on this for a few years now and have posted a lot in my HN comment history and technical blogs about how I have iterated on and evolved this workflow to the point where it is now