I’ve been using Obsidian as a note-taking app and platform for various personal stuff for almost three years, and that’s probably the longest I’ve stayed with any kind of systems of that type, so it’s a good subject for a post 🙂 I want to give an overview of my current usage, partly as “here’s how I use this tool, maybe it can be useful to you too” and partly as “it’s possible I will have forgotten everything about this in 6 months, so let’s write a few notes to be able to dive back into it if I want to.”

Obsidian is, essentially, a pile of Markdown with an editor on top and inter-document links. It has applications for Linux, Windows and Android (and probably more). The base version is a single (or multiple) piles of Markdown called a vault; they offer a (paying) sync service to be able to use the same vault on multiple device (but some people deal with the sync manually.)

Obsidian also has a healthy library of plugins for various use cases from “basic productivity tools” to “here are tools to manage your D&D campaign”. Beyond my initial basic setup, I’ve been adding a bunch of these plugins to be able to handle a couple of more advanced applications – namely a meal planner, and a basic journaling/tracker setup that has been working for me better than anything I tried to use so far.

My initial “basic” setup

I’ve been using it for various projects, including planning AlphabeticalZurich (which is in sleeping mode these days, but eh) and taking daily notes for work. Some things work for me, some don’t really (for now / these days – doesn’t mean they won’t work next month!). The one thing that works reasonably consistently is my work log. I use the DailyNotes core plugin, and I use a weekly file for these; on each weekly file, I add the date as a heading for every day in which I take notes (ideally that would be every day I work, but that’s… ideally), and I use the Templates core plugin to handle automatic insertion of date and time (I timestamp my entries, it gives a tiny bit of structure and gives me some idea of where I spend my time). I also use the Checklist plugin – if I have a specific actionable item to handle, I put a #todo hashtag in my weekly note, add the corresponding checkbox, and it goes automagically in the TODO list on the side. I also take the occasional meeting note, and/or some notes whenever I’m exploring a larger piece of code/project – that does tend to end up on paper, though.

Besides work-related things, I also have a few other files in there – mostly loose project ideas/brain dumps; some travel planning. I’ve tried to store a few other things – book notes, health management, restaurant notes. But, nothing of that nature really stuck yet; this is not even on the “aspirational” side of things, it may be more on the “I’d really want to want to do that sort of things” side of things 🙂

Still, as it is, it’s already very helpful – I have notes, with dates, that are searchable, and if I’m feeling fancy I can even have links between them (and a loose TODO list). It’s not the “second brain” that some people claim they can use and maintain, but it’s a useful tool in my toolbox.

Meal planner

One of the recurring tasks that always takes more brain power than it feels like it should is planning meals for the week. A little while ago, I created a second vault (called, surprise surprise, “meal planner”). A large inspiration for my setup was an Obsidian forum post, “Obsidian as Recipe Manager and Shopping list (Tutorial)” – it might be how I got familiar with the Checklist plugin, now that I think of it. As a caveat: this doesn’t completely work for me these days (I may or may not have another solution cooking, pun intended), but it did give me some ideas about what I actually did want for such a system. (This may well be one of the places where Obsidian shines, when it comes to personal tools: rapid prototyping that can be iterated on or let go if they Just Won’t Work For Me.)

For this vault, I essentially have one file per meal (which may be either a recipe on itself, or link to other recipes if some get combined easily). Most of the data that I *actually* use for this are in the Markdown metadata block, which can look like this:

---
made-on:
  - 2025-01-22
source: Ottolenghi "Simple", p 104
portions: 2
tags:
  - meal
  - recipe
  - vege
protein: tofu
vegetable: haricots verts
carb: riz
---

(I’m sure it won’t surprise anyone that I can’t decide between French and English on my meal planning.) In my ideal world, there would be an entry for each time I cooked this, because in my ideal world, that’s a piece of information I can use for my planning. I have the information SOMEWHERE (because we have a reasonably up-to-date spreadsheet for our meal planning), and I could input that data if I really wanted to. In the Markdown itself, I oftentimes have nothing; I might have recipes that I store there; and I may have a list of ingredients. The tutorial I started using was using Checklist as a way to gather ingredients for a shopping list – this requires more consistency than I have for data input to be at all useful.

The use I imagined for this is leveraging the file metadata thanks to Dataview (which the original forum post was also doing), and my set of queries is mostly based on “number and recency of times I’ve cooked a given meal” (which, as mentioned, would require more data input than I apparently manage to do.)

## It's been a while
```dataview
LIST from #meal  
WHERE length(made-on) > 0
SORT slice(reverse(sort(made-on)), 0, 1)
```
## Favorites
```dataview
LIST from #meal 
where length(made-on) > 0
sort length(made-on) desc
limit 10
```
## To try
```dataview
LIST from #meal 
WHERE length(made-on) = 0
```
## Vegetarian
```dataview
LIST from #meal and #vege
sort length(made-on) desc
limit 10
```
## Leftover-friendly
```dataview
LIST from #meal 
where portions > 2
```

Since I had made this thing, Obsidian also has its own implementation of database-like views of notes with Bases. I also have a view of my recipes, which enables me to see/sort through meals rather than relying on some criteria and a limit on the number of lines.

Finally, I use the Dice Roller plugin to create a list of a few randomized meals with “one protein / one vegetable / one carb”, when inspiration is really lacking. I have three files (one for each category) with one suggestion per line, and I have a few lines such as

`dice: [[Proteins]]|line` `dice: [[Vegetables]]|line` `dice: [[Carbs]]|line`

at the end of my planner file to give me a few random choices (that can be re-rolled as desired).

This planner doesn’t quite work for me right now, because (a) I actually want to plan a full week of menus, and not necessarily only one idea for one line of my spreadsheet (b) the way I made it would require more consistency in the input for it to be useful with the constraints I was thinking about. Anyway, this informs the next version of this thing, and it has actually been useful to think about how I wanted to solve this problem. (But, on a whim, I still run the planner and it can help, despite my lack of data input, so there’s that.)

Journaling

I’ve had a couple of conversations recently that made me think that a very basic journaling thing with a few easy fields to fill, and a free text field if I really want to add more, could be a good thing to have. That’s one of the things where I’ve tried many solutions, but they’re often either phone-app-only, or are overwhelming for the basic things that I want, or a mix of both. My latest foray(s) in Android-development were going in that direction, but never went anywhere (probably because… I actually don’t want a phone app for this).

Recently, I’ve dug into what people in the Obsidian ecosystem use, and I’ve landed on a few things that seem to work well enough together and do what I want to do. The core element is what’s currently in my daily template, which contains the following code:

---
date: "{{date}}"
---
Energy:
```meta-bind
INPUT[inlineSelect(
    option(low),
    option(mid),
    option(ok),
    option(high)
):energy]
```
Pain
```meta-bind
INPUT[inlineSelect(
	option(none),
	option(ignorable),
	option(low distress),
	option(distracting),
	option(high distress)
):pain]
```
Focus
```meta-bind
INPUT[inlineSelect(
	option(low),
	option(mid),
	option(high)
):focus]
```
Mood
```habittracker
{
	"daysToShow": 1
}
```
## Notes

The Meta Bind plugin creates some input fields, which feed the Markdown metadata. I have three drop-down fields there, with values that make sense to me (rather than someone else’s idea of what makes sense for most people).

The other field uses Habit Tracker 21, which is normally used more as a table to display streaks and the like, but which I use here as a single column display for the current day. (Caveat: this requires to fill in the tracker before midnight, otherwise some annoyances happen.) The input of Habit Tracker 21 is a directory containing (you’ll guess) a pile of Markdown files; it stores its data as a list of ticked dates in the metadata of the file in question. I use this for mood tracking, and any mood (say, “grumpy”) is associated to a file that only contains a list of date entries. On of the nice thing about that is that adding a specific entry in that table is as easy as adding an empty file in the correct directory.

Tying this together is a “Dashboard” file in the vault, which uses both Habit Tracker 21 (but this time with a larger time window), as well as Heatmap Calendar, which displays the field filled in by Meta Bind as a colorful calendar that gives an overview of the data I’m filling in the daily notes. This could PROBABLY be cleaner (in particular, I’m pretty sure the heatmap isn’t necessarily best used for discrete values…); but it also demonstrates that Dataview can be used both with a SQL-like interface as in the menu planner, and as a way to fill in data structures in JS (most of the code here is a fairly direct adaptation of the documentation.)

```dataviewjs
const energyCalendar = {
	colors: {   
		palette: ["#e73400","#ffb244", "#49af5d", "#49ee5d"]
	},
	defaultEntryIntensity: 1,
	intensityScaleStart: 0,
	intensityScaleEnd: 3,
	entries: [],
}
const focusCalendar = {
	colors: {
		palette: ["#e73400","#ffb244", "#49af5d"],
	},
	defaultEntryIntensity: 1,
	intensityScaleStart: 0,
	intensityScaleEnd: 2,
	entries: [],
}
const painCalendar = {
	colors: {
		palette: ["#49ee5d","#30aa5d","#ffb244", "#e73400", "#990000"],
	},
	defaultEntryIntensity: 2,
	intensityScaleStart: 0,
	intensityScaleEnd: 5,
	entries: [],
}


for (let page of dv.pages('"Journal"')) {
	var energy;
	switch(page.energy) {
		case 'low':
			energy = 0;
			break;
		case 'mid':
			energy = 1;
			break;
		case 'ok':
			energy = 2;
			break;
		case 'high':
			energy = 3;
			break;
	}
	energyCalendar.entries.push({
		date: page.file.name,
		intensity: energy,
	})
	
	var focus;
	switch(page.focus) {
		case 'low':
			focus = 0;
			break;
		case 'mid':
			focus = 1;
			break;
		case 'high':
			focus = 2;
			break;
	}
	focusCalendar.entries.push({
		date: page.file.name,
		intensity: energy,
	})
	
	var pain;
	switch(page.pain) {
		case 'none':
			pain = 0;
			break;
		case 'ignorable':
			pain = 1;
			break;
		case 'low distress':
			pain = 3;
			break;
		case 'distracting':
			pain = 4;
			break;
		case 'high distress':
			pain = 5;
			break;
	}	
	painCalendar.entries.push({
		date: page.file.name,
		intensity: pain,
	})
}
dv.span("** Energy level **");
renderHeatmapCalendar(this.container, energyCalendar)
dv.span("** Focus level **");
renderHeatmapCalendar(this.container, focusCalendar)
dv.span("** Pain level **");
renderHeatmapCalendar(this.container, painCalendar)

```


```habittracker
{
}
```

Conclusion

So there, that’s my current usage of Obsidian. There’s probably more to be done; I found out the hard way that for anything at all to work for me, the regular input needs to be either minimal (that’s the journaling use case) or optional (that’s the case for my work notes – ideally it wouldn’t be optional, BUT if I lapse, getting back on the horse has literally no friction). Letting go of the desire to Organize Things Perfectly has been a challenge for me, but absolutely necessary as it tends to conflict with the desire to Resist What I Should Be Doing. In that sense, “pile of Markdown” is the right structure for me: when it works, I make it well-organized enough, but it’s very robust to “I haven’t used this for 3 weeks and I really should have” – well, that’s a hole in the input that’s also not BLATANTLY a hole in the input (which makes it harder to come back to it), it’s typically just a file that doesn’t exist.

My other best friend these days is Todoist, which I’ve been using as a “list of things to do today or at least soon-ish-enough”; it’s a bit awkward to have both some tasks in Obsidian for work and some tasks in Todoist, but so far it’s been working well enough. The context is subtly different, and I use both applications for different ways of managing Things I Want Or Should Do; it’s been working for more than a few months now, and that’s probably the longest anything has worked so far. Doesn’t mean it will still work next month (I know myself!), but even if it doesn’t, it might also come back in 6 months (because it’s proven functional by now.)