Ask HN: What products other than Obsidian share the file over app philosophy?

Recently I've been using iAPresenter [1], which lets you build presentations using Markdown. I actually use it to create branded PDF proposals for clients and it makes life much easier than having to use Google Slides, Keynote or Powerpoint. The philosophy of iAPresenter (and iAWriter) is more about minimizing distractions, but the side effect is that you end up in control of your files too.

Another tangential example is Dropshare [2], a Mac app for sharing files. You can plug in your own backend (S3, Backblaze etc.) and domain and have your own branded file sharing service, while "controlling" your files (although they are obviously still hosted on a 3rd party server)

[1] https://ia.net/presenter

[2] https://dropshare.app/

I always insist to use plain ASCII text format to write the specification of any file format, since otherwise it will be difficult to read the specification in order to be able to implement it, so that you can read it. So, using file formats that are easy to retrieve and to read is especially important if the file contains the specification of another file format (I dislike that many formats unfortunately don't). This is also true of the protocols for accessing the file; a simple explanation should be possible in only a few sentences which is sufficient for accessing the specification file itself, even if the actual protocol is more complicated than that. However, in any case, there will be complexity in the other parts to support them (e.g. ASCII, MS-DOS, TCP/IP, etc), but hopefully you can use what is simpler than the alternative.

The idea of ”local first” is sort of related: https://www.inkandswitch.com/local-first/

I think tldraw is an application that does this well in the browser. When you open it up you can start working right away, your work is automatically saved in localstorage or similar, but you can always save to a file. And you can also click share and get live collaboration on the document. Saving to a file still works the same.

It’s best of both worlds I think. I get the convenience of a web application with sync/collaboration, and I have control of the files if I want to. The format is plain JSON and if the original application goes away I could put together a renderer so that I can view the file.

FSNotes for macOS and iOS is one I used for a little while.

https://fsnot.es/

todo.txt is another thing that comes to mind.

http://todotxt.org/

And of course pretty much all of *nix.

NotePlan (https://noteplan.co) stores everything in Markdown files with a directory structure mirroring that created in the UI

I guess many of the static site generators would qualify. Hugo does. Haven’t used any others but I think that’s also true for Jekyll, Zola etc etc.

Logseq is a good example of this

There are flat-file CMSes (content management systems) like Grav: https://getgrav.org/

Ironically, old-fashioned desktop office apps (Microsoft's or otherwise) save their outputs in a relatively parseable, self-contained XML format, but that's so rare to see in today's world when everything is like fifty JSONs and YAMLs and build artifacts spread across disparate systems and CDNs and such.

There are some interesting file formats that encode temporal elements alongside content, like video subtitles (SRT), chess game recordings (PGN), some simpler video game save files, etc. They're different from binary video/audio blobs in that they're entirely human-readable too.

In code, there are some rules engines that attempt to declaratively encode logic into flat JSON instead of conditional operators: https://github.com/CacheControl/json-rules-engine

I guess, in some vague/broad sense, maybe config-as-code systems also implement a similar philosophy? Maybe even OpenAPI schemas could count to some degree...?

In the old days, the "semantic web" movement was an attempt to make more webpages both human- and machine-readable indefinitely by tagging them with proper schema: https://en.wikipedia.org/wiki/Resource_Description_Framework. Even Google was on board for a while, but I guess it never saw much uptake. As far as I can tell it's basically dead now, both because of non-semantic HTML (everything as a React div), general laziness, and LLMs being able to parse things loosely.

Maybe a continuation of that effort is the Wikidata movement, which is trying to add schema and semantic data to other MediaWiki projects whenever they can: https://www.wikidata.org/wiki/Wikidata:Introduction

-------------

Side thoughts...

Philosophically, I don't know that capturing raw data alone as files is really sufficient to capture the nuances of any particular experience, or the overall zeitgeist of an era. You can archive Geocities pages, but that doesn't really capture the novelty and indie-ness of that era. Similarly, you can save TikTok videos, but absent the cultural environment that created them (and a faithful recreation of the recommendation algorithm), they wouldn't really show future archaeologists how teenagers today lived.

I worked for a natural history museum for a while, and one of the interesting side questions (well, to me anyway) was whether our web content was in and of itself worth preserving as a cultural artifact -- both so that future generations can see what exhibits were interesting/apropos for the cultures of our times, but also so they could see how our generation found out about those exhibitions to begin with (who knows what the Web will morph into 50 years later). It wasn't enough to simply save the HTML of our web pages, both because they tie into various other APIs and databases (like zoological collections) and because some were interactive experiences, like games designed to be played with a mouse (before phones were popular), or phone chatbots with some of our specimens. To really capture the experience authentically would've required emulating not just files but also our tech stacks and devices, among other things. And that doesn't even begin to address the cultural aspects. (Ultimately, this was important to nobody else, and it all just disappeared forever, lol.)

Like for the earlier Geocities example, sure you could just save the old HTML and render it with a modern browser, but that's not the same as something like https://oldweb.today/?browser=ns3-mac#http://geocities.com/ , which emulates the whole OS and browser too (https://github.com/oldweb-today/oldweb-today?tab=readme-ov-f...). And that still isn't the same as having to sit in front of a tiny CRT and wait minutes for the 386 to boot and everything to download over a 14.4k modem, only to be interrupted when mom had to make a call.

I guess that's a longwinded way of critiquing "file over app": It only makes sense for things that are originally files/documents to begin with. Much of our lives now are not flat docs but "experiences" that take much more thought and effort to archive. If the goal is truly to preserve those for posterity, it's not enough to just archive their raw data, but to also develop ways to record and later emulate entire experiences, both technological and cultural. It ain't easy!

Anki!