
Roam – Tool for Thinking - pps
https://roamresearch.com/
======
conaws
Cofounder here -- just want to let people know that we STRONGLY believe that
your data shouldn't be trapped in a SAAS application.

Roam does allow you to export all your data to an org-mode file (the emacs
outliner), we're working on other import/export options, and want to get to
the place where there is a __close to __plain text representation of your Roam
workspace on your file system that syncs both ways.

We weren't expecting someone to post us to HN yet. This is a case of, if
you're not embarrassed on launch, you launched too late. Just want to let
y'all know we dont believe in SAAS lockin for a tool for thought, and data
portability for the folks who aren't emacs users is coming.

~~~
conaws
Also -- for folks asking about how we're different from Workflowy or Evernote
or existing wiki tools

Key claim we have is that knowledge doesn't really fit into the tree structure
of a file system (nearly 100% of knowledge management tools follow that
structure)

In Roam, you can organize things hierarchically -- using indentation -- but
when you link to another page, the paragraph or bullet point where you made
that link appears in the "references" for that page.

Pages -- like a page for a person, or a concept -- end up getting a sort of
implicit definition from all the other places where you talk about them.

So, a page for Alice or Bob for example has all the tasks that have been
assigned to them, and all notes from meetings that involved them.

A page for a concept like [[Paul Graham recommends Clojure]] pulls in all the
paragraphs or bullet points where you used the term -- and the bullet points
nested below.

------
autocorr
I came upon this while looking up things related to Zettelkasten or "card box"
style note taking. It would be helpful to have more information about the tool
on the page rather than all of the testimonials (which don't really answer why
this is better than something like WorkFlowy except that one references it).
Without signing up all you can infer from the schematic and comments are that
this is like a wiki that reports back-links.

As a separate comment, I've had really great success using Zotero for this
purpose. I already ingest all the journal articles, book references, etc I
read into it using the Zotero browser plugin. You can tag items and (bi-
directionally) link related items, and add notes with its inbuilt HTML note
system. I just have one folder that contains my notes and link them to each
other. You can also attach reading notes to the bibliographic entries
themselves and have separate folders for project specific notes. A weakness
however is that the links do not appear as hypertext in the body of the note
but instead in a pop-up menu.

~~~
Philipp0205
Good recommendation. Thanks!

------
gatherhunterer
This looks interesting but I could never fully commit to it because it seems
to run as a SaaS product. If I am building a personal knowledge compendium I
want to own and manage that data myself, it’s not enough to just have access.

~~~
SrslyJosh
This. I can't (for professional reasons) and won't (as a matter of principle)
store my notes in a service like this. =(

~~~
chrisMyzel
Can not agree more

------
TuringTest
There are a lot of attempts to create the perfect personal information
management application, as there's a real need for this kind of "augmented
intellect" tool.

Several of these tools are converging on a similar design for an "active
outliner", joining the power of a wiki with the programmability of a
spreadsheet. The killer app will be the first one to get the interaction model
right for a generic "information workers" audience.

~~~
pgaile
Hmmm... Curious as to what is out there now. Can you please point me in the
right direction with a list of available Apps. Regards, Peter \-- Peter Gailey
The PIMCoach See PIMCOACH.com pgailey@gmail.com 214-336-1286

------
emerongi
If you want to sign up without subscribing to marketing e-mail, this seems to
be the actual registration url:
[https://roamresearch.com/#/secretinvite](https://roamresearch.com/#/secretinvite)

------
charlesdaniels
I use Joplin[0], mostly because it's the only thing I've found that has a
client that works offline on Linux. (There's also TagSpaces, but the UI never
really clicked with me).

I've often wished to have a "graph" feature where notes could be linked
together, and you could see some kind of cluster, or maybe do queries based on
number of edges from something. Stuff like that.

It _sounds_ like this tool would offer something like that. But just the
front-page doesn't really show enough to be sure if I would find it useful or
not. I'm not going to create an account to spent 5 minutes fooling with
something I may wind up not liking and never using again.

If the Roam people are reading this thread, maybe think about adding a
screenshot gallery, an interactive demo that doesn't need an account, and/or a
demo video showing off the key features.

I would potentially be willing to pay for a notes app, but as others have
noted SAAS has some problems. The data portability / vendor lock-in aspect can
be solved by supporting export into common formats, but this also functionally
precludes offline use. That would be a non-starter for me personally.

0 - [https://joplinapp.org/](https://joplinapp.org/)

~~~
The_Colonel
For the graph feature check out Trilium Notes:

\- [https://github.com/zadam/trilium/wiki/Link-
map](https://github.com/zadam/trilium/wiki/Link-map)

\- [https://github.com/zadam/trilium/wiki/Relation-
map](https://github.com/zadam/trilium/wiki/Relation-map)

The links between notes are stored as rows in a relational database (SQLite)
so if you're not afraid of a little bit of scripting, you can easily query by
e.g. number of edges if you want ...

------
TuringTest
My go-to list of requirements for a "personal thoughts" tool:

\- file-based, so that: * migrated to other tools * edited with robust classic
text editors * copied, synched and backed-up with external file tools

This is essential so that persistence of the valuable knowledge stored in the
application won't depend exclusively on its (fragile) internal tools, but can
be managed as a system-level admin task.

\- Tree-based, but with external links, to allow for arbitrary network shapes
(the basic "tree" outliner shape can be augmented with links to other parts of
the network, without having to copy the whole sub-tree)

\- Multi-directional (incoming+outgoing) links (This is hard to see in most
outliner note-taking tools, but Roam does it pretty well)

\- Easy navigation of parts of the tree through breadcrumbs (allows avoiding
the "humongous tree of death" by creating "local navigation" views). Workflowy
does this very well.

\- Tag-based persistent filters that can be stored as nodes in the tree (i.e.
you don't need to search in the search bar for a combination of tags every
time you want to recover it). With this, you can create new concepts by
storing persistent complex searches as part of the tree.

\- Easy to set up, share, and use in multiple devices and OSs (mobile and
desktop).

~~~
AriaMinaei
I agree with with all those requirements except for the first one.

I think there should be a way to _export_ to files/directories, but using
files/directories as the primary persistence mechanism is inherently limiting:

\- Editing things with classic text editors loses the intent of each edit.
Ever seen a git diff look radically different from what your changeset
intended? That's because a simple A/B comparison cannot recover the
_intention_ of each edit. You lose information here. Like, did the user change
the name of function A, or did she define a new function that looks a lot like
function A? \- Backing up with external tools will work. But syncing will be
limited. Because the sync tools don't understand the structure of the
document. \- How does the tool assign a unique ID to the smallest unit of
content (say, a word, or a link, or a paragraph?) \- Editing files with a
classic text editor will also break real-time collaborative editing.

~~~
The_Colonel
I totally agree. Filesystem works only for the simplest of use cases. Besides
what you mentioned, their requirement of "Multi-directional
(incoming+outgoing) link" is essentially impossible to do well with file based
approach:

\- the only identifier of a file is the path, once you rename a file, all the
links pointing to it are broken

\- for incoming links you'd have to scan the rest of the notes for links
(which will get slow at some point)

Typical way to mitigate this is to create some index files, name note files
with UUIDs instead of their natural names, but this then creates a lot of
other problems as well.

You might also find out that the limitations of filesystem (strict tree
structure, strict split between directories and files) might not be a best fit
for note structure ...

~~~
TuringTest
I was thinking of a system where the _content_ of the nodes is persisted as
files, like in static website generators, and then the interactive view is
generated from the content read in files when the application starts or is
updated.

Wikis work that way, where the payload of each page is a flat text sequence
with simple markup.

The structure, relations and metadata could then be stored in a serverless
database, like Git does in the .git folder. Not perfect, but I think the
benefits for personal information outweight the limitations.

~~~
The_Colonel
> Wikis work that way, where the payload of each page is a flat text sequence
> with simple markup.

That depends on the wiki. The most well known - MediaWiki - uses traditional
DB like MySQL or Postgres.

> The structure, relations and metadata could then be stored in a serverless
> database, like Git does in the .git folder. Not perfect, but I think the
> benefits for personal information outweight the limitations.

What happens when files and metadata go out of sync? People want to have the
data in plaintext for interoperability with other tools so they are going to
edit the data outside of the app. And your app does not know files changed so
it can't selectively update the indexes/metadata.

Another motivation for flat files is that users want to use standard sync
tools like syncthing, dropbox etc. But these metadata and indexes will not
work at all in case of write conflicts - dropbox does not know how to merge
those serverless database files.

~~~
TuringTest
> Wikis work that way, where the payload of each page is a flat text sequence
> with simple markup. That depends on the wiki. The most well known -
> MediaWiki - uses traditional DB like MySQL or Postgres.

They still persist each page as a self-contained single flat text field,
though. For the wiki model, it doesn't matter how it is stored in the hard
drive, but that you get atomic nodes of content. If the node is a text file,
you get the benefit of accessing such content through the file system and a
text editor instead of a DBMS. That's invaluable for accessing content from a
collection of multiple devices, operating systems and alternative
applications, i.e. the use case for personal information.

> And your app does not know files changed so it can't selectively update the
> indexes/metadata.

Why would the app not know that files are changed? Any development environment
nowadays may check for touched files and re-parses them on the fly, for
example for instant preview of web pages.

~~~
The_Colonel
> Why would the app not know that files are changed? Any development
> environment nowadays may check for touched files and re-parses them on the
> fly, for example for instant preview of web pages.

Modern OS provide APIs to watch file changes (on Linux e.g. it's inotify).
However:

1) Does not work when your app is not running. When your app starts up it
needs to rescan all files.

2) Does not scale well - watching files is expensive and OS usually have usage
limits.

IDEs provide a great example since they need to solve essentially the same
problem - when my Intellij starts up it spends a while until it scans all the
changed files (to do that it must go through all of them). After that it
starts complaining that my inotify OS limit is too low and it can't watch all
the files in the project.

All this is fine for lightweight use. But if you're serious with using your
knowledge base, you'll run into tens of thousands of items in the course of
few years.

------
short_sells_poo
Maybe I'm a bit jaded but it feels like this takes the "minimalist UI" too
far?

I have no clue why this is good. It talks about DAGs as a way to organize
research, but there is almost zero information about anything really.

How exactly does this help me?

~~~
vladsanchez
Try Gingko[1] instead. Look it up on Youtube too. ;-)

[1] : [http://gingkoapp.com](http://gingkoapp.com)

------
bn7t
This looks very similar to Trilium Notes [0] which I use.

[0]: [https://github.com/zadam/trilium](https://github.com/zadam/trilium)

~~~
bayindirh
Also there's Zim wiki [0] which runs on the desktop. I use it to create a ton
of notes and knowledge piles.

Zim's UI looks more dated and simpler, but underneath it's extremely powerful.

[0]: [https://zim-wiki.org/](https://zim-wiki.org/)

~~~
canada_dry
+1 for Zim.

The UI is utilitarian, simple and efficient. It stores all of its note files
as .txt so there's lots of other ways to access the info (e.g. grep).

Zim is extensible with a variety of useful plugins too.

~~~
bayindirh
I use it with the plugins enabled and, it helps a great deal for my knowledge
organization and acquisition.

Its simple file structure also allows me to pair it with syncthing [0], and
sync all of my computers with each other seamlessly. So I have my own self-
syncing document trove and knowledge base without any considerable effort.

Using simple apps and integrating them is much more powerful than it looks,
and it's one of the simpler things that I enjoy immensely.

[0]: [https://syncthing.net/](https://syncthing.net/)

------
hmhrex
This reminds me a lot of Notion. I've been using it for a while now and love
it. I may check this one out too.

[https://notion.so](https://notion.so)

------
celeritascelery
Looking at this, it immediately reminded me of Emacs org-mode. The ability to
manage agenda and notes and link Them all together. In fact, org-mode is often
used for research as well

[https://www.r-project.org/conferences/useR-2011/TalkSlides/C...](https://www.r-project.org/conferences/useR-2011/TalkSlides/Contributed/16Aug_1115_FocusI_4-ReportingWorkflows_3-Leha.pdf)

~~~
DesertVarnish
At one point, Roam supported importing org-mode files (my team actually asked
them to implement it back in spring of 2018). The product vision has changed a
lot since then and I'm not sure if they still support it, but if there's
interest I wouldn't be surprised if they brought it back.

~~~
conaws
You can import any plain text or markdown file into Roam -- we take the
indentation structure and parse it out.

Can also copy/paste in any html

Would build a special emacs importer if there was strong need -- but emacs
export is so powerful you can also just export org-files into a format that
Roam accepts already

------
solarkraft
Tip for people wanting to register: Don't enter your real e-mail address into
the first sign-up mask. All it will do is subscribe you to a newsletter and
forward you to an actual sign-up form (in which you can indeed opt to use
Goolge to log in).

The app itself seems neat so far. Native and powerful bullet point notes apps
are something I'm constantly looking for because I haven't yet found the
perfect one. This seems like a good contender (though ultimately I want
something self hosted).

Is this completely based on the org mode file format or does it only have an
exporter for it?

------
conception
Similar - [https://workflowy.com/](https://workflowy.com/) \- Workflowy has
been the one product to stick for note and task taking. Highly recommended.

Roam seems to have a lot of the same concepts.

------
97-109-107
This seems like a real application of Xanadu's concept
[https://en.wikipedia.org/wiki/Project_Xanadu](https://en.wikipedia.org/wiki/Project_Xanadu)

~~~
pratio
That's the first thought that came to my mind. I love hearing ted nelson
explain it
h[https://www.youtube.com/watch?v=1gPM3GqjMR4](https://www.youtube.com/watch?v=1gPM3GqjMR4)
It is a good effort to bring that concept to life.

This video is better
[https://www.youtube.com/watch?v=hMKy52Intac](https://www.youtube.com/watch?v=hMKy52Intac)

------
slaymaker1907
My preferred tool for this sort of thing is tiddlywiki. Very easy to both use
and extend.

------
TurkishPoptart
Without having signed up or even tried the actual product, I'm curious as to
how many products are exactly like this. How is this different from Evernote,
or the MS/Google equivalents?

------
faeyanpiraat
Your sales page took away my precious scrollbar :(

------
nonoesp
Anyone else thought of Dropbox Paper when they saw the landing page?

