Note Inheritance and making notes into Nodes

I come from an Object Oriented programming background and I often find myself thinking in terms of objects even when I am making notes.

Proposed solution

Instead of a note simply being a note, have all notes by default be “Nodes” or “Objects”.
When you create a new Node you can declare at the top if this Node extends any templates (Also a node) and you can also have the node “contain” other nodes. In this way all nodes are templates and all templates are nodes.

This is different than linking. When a node “contains” another node, it is a new instance of that type of node.

Example of use: Let’s say you have a base template or node “Person”. In the template you make space for ##Appearance, ##Likes and Dislikes, ##Fears.

Now you want to create a new new Node “Scientist” which has everything “Person” does as well as ##Notable Discoveries. The Scientist node will have at the top “extends Person”. As soon as you this everything from person will pop down into the node
's note space.

You may say you an already do this with templates but that is not entirely true.
Consider now that you use the person and inventor node to create a few Scientists in your notes. You created Albert Einstein, Isaac Newton, and Richard Feynman.
Then later you decide you want to add ##Personality to the person node. With the way templates currently are you would have to go in and manually add that to every note that you used the template on. Not convenient for 100s of notes.

With the purposed system, you could simply go to the person node and add the line ##Personality, and every node that has “extends person” will automatically receive this change.

One last part of this feature is that Nodes can also “Instance” other nodes within themselves. This is different from linking which will lead back to the same exact Note every time, sort of like a singleton in Object Oriented Programming.

To continue with the above example let’s say later you decide that ##Personality should be a node itself, because you want to have a more detailed structure for a personality. So you create a new node “Personality” and in “Person” you replace ##Personality with “has [[Personality]]” (the exact syntax can bye discussed). This is different from linking, with regular linking you would have a link to the concept of a Personality. In this case we want each person to have a personality. So in this way, now when you click on [[Personality]] in "has [[Personality]], it would create a new node that extends [[Personality]] and that node would be attached to the parent node.

You are writing EInstein’s note now and since it “extends Person” you see now it has an update link in the note. “has [[Personality]]”. You click this and you can begin to fill out a new note Einstein.Personality that is a separate note from Newton.Personality.
When the new Personality node opens up, it immediately follows the template from the Personality Node and updates if you make changes to it.

All of this is completely optional to use and existing users can use “Nodes” just as “Notes”

Current workaround (optional)

The current way I am getting a similar structure is using the folder notes plugin, many templates, and having those templates have keywords I create which help me to be organized for example all of my notes have a “Parent”: at the end which show links only to a parent note.

Related feature requests (optional)

Include a hierarchy tree view, similar to a folder tree view, although it displays the hierarchy of nodes


This is an interesting Idea and as a programmer myself I love abstraction. The concept what I love about the idea is that I can write maybe more of an interface that promises certain information and obsidian could warn me where information is missing. We could use the tags to denote what kind of interface something is and what is expected to be in that interface. Then you could supercharge templates and link them to an interface/tag that will display a certain type of data some sort of way, and you’d be able to update this later on. If you’d update the interface/tag, there could be a list of notes where that data is missing, and you’d be notified somewhere so that you can review & correct it.
The added functionality is that with a system like this, there is a way to define the structure you’d expect a note to be. This makes quality management easier when you’re using part of Obsidian for more of a personal database type of role. Like when managing tasks or books.
Of course, it becomes really important in how you’re able to define the interface. A few Ideas:

  • define chapters
  • define yml & dataview annotation requirements.
  • some sort of regex matching.

This could make it so that it’s easier to make notes atomic and not having to duplicate information. An interface defines what the note is about, and a ‘supercharged template’ (we could call it a ‘structure’) defines the context for a certain interface, just like an abstract class.

I’d love to hear your ideas of my interpretation on this. If this is not something the obsidian team wants to pick up, with some effort it could be implemented as a plugin.