How often have you found yourself struggling to recall a brilliant idea, only to watch it slip away into the chaos of your mind? In today’s information-saturated world, managing our knowledge effectively is more crucial than ever. Enter the concept of a “second brain,” a digital repository that captures, organizes, and retrieves information, allowing our biological brains to focus on creativity and decision-making.
I recall the frustration of juggling multiple projects and interests, from public speaking to writing and streaming, without a cohesive system to manage my notes and ideas. For many years, I relied on the Bullet Journal methodology, which was indispensable for tracking activities and tasks. However, it fell short as a tool for compiling research and creating referenceable information for creative projects. I needed more—a system that could handle the complexity of my ideas and projects.
Enter the second brain methodology. By integrating tools like Obsidian and Neovim, and ensuring seamless access across devices, I was able to build a comprehensive system that complements the Bullet Journal approach. Here’s how I built my second brain and how you can too.
Understanding the Second Brain Concept
Tiago Forte popularized the concept of a “second brain,” which is essentially a personal knowledge management system that functions as an external memory. This system is built on the C.O.D.E. method: Capture, Organize, Distill, and Express. By using a digital platform to store and manage information, we relieve our minds of the burden of remembering everything, allowing us to focus more on creativity and problem-solving. To ensure long-term benefits and consistent use, it’s crucial to seamlessly incorporate this digital platform into your existing workflow.
Why Choose Obsidian?
Obsidian stands out as a powerful note-taking application due to its unique approach to linking notes, fostering a network of interconnected ideas. Unlike many popular note-taking apps, Obsidian is primarily a local tool, storing notes directly on your device. This local-first approach ensures that your data is “secure by default,” giving you complete control over your information without relying on third-party data stores. Sharing notes across devices is entirely optional, allowing you to choose how and when to sync your data, whether through cloud services or peer-to-peer solutions like Syncthing.
Advantages of Obsidian Over Other Apps
Markdown-Based: Obsidian uses markdown, a universally accessible format, ensuring your notes are not locked into a proprietary system. This flexibility allows for easy access and editing across different platforms and tools. In contrast, apps like Evernote store notes in proprietary formats, which can limit interoperability.
Bidirectional Links: These links create a web of knowledge, enhancing understanding and retention by mirroring how our brains naturally connect ideas. Many long-time Obsidian users consider this feature the app’s “super-power,” as it transforms notes into a dynamic network of concepts. While apps like Notion offer linking capabilities, Obsidian’s focus on bidirectional links and graph visualization provides a more intuitive exploration of relationships between notes.
Customizability: With a plethora of plugins and themes, Obsidian can be tailored to fit any workflow, from simple note-taking to complex project management. This adaptability makes it suitable for a wide range of users, including students, professionals, and researchers. Unlike OneNote, which offers a more fixed structure, Obsidian allows users to customize their environment extensively.
Local Storage: By default, Obsidian stores notes locally, providing enhanced security and privacy. Users can choose how and when to share their notes, ensuring data remains under their control. This feature is particularly appealing to those concerned about data privacy and ownership, unlike cloud-reliant apps such as Google Keep.
Dynamic Exploration: Obsidian’s graph view allows for visual exploration of your notes, providing a holistic view of your knowledge base. This feature is especially beneficial for visual learners and those managing complex projects or research. While tools like Workflowy offer hierarchical organization, Obsidian’s graph view provides a more interconnected and visual representation of information.
Leveraging Neovim for Enhanced Productivity
Neovim, a modern fork of Vim, offers a highly customizable text editing experience that resonates strongly with technical professionals. Its integration with Obsidian through plugins like obsidian.nvim creates a powerful environment for note-taking and knowledge management, particularly appealing to those comfortable with command-line interfaces and Vim-style editing.
Who Benefits from Using Neovim for Note-Taking?
Software Developers and Engineers: Those who spend their days in code editors will find Neovim’s modal editing and extensibility familiar and efficient. The ability to manipulate text and navigate through notes using keyboard shortcuts can significantly speed up the note-taking process.
Data Scientists and AI Engineers: Professionals working with large datasets and complex algorithms can leverage Neovim’s powerful search capabilities and ability to handle large files. This makes it ideal for maintaining extensive research notes, code snippets, and project documentation.
DevOps and System Administrators: Those who frequently work in terminal environments will appreciate the seamless integration of note-taking into their existing workflow. Neovim’s ability to run shell commands directly from the editor can be particularly useful for documenting system configurations or troubleshooting steps.
Technical Writers and Documentation Specialists: The combination of Markdown support and Vim’s efficient text manipulation makes Neovim an excellent choice for those who need to produce and manage large amounts of technical documentation.
Open Source Contributors: Developers actively involved in open source projects can benefit from Neovim’s Git integration, allowing them to manage project notes alongside their code contributions.
By leveraging Neovim’s extensibility and combining it with Obsidian’s knowledge management features, technical professionals can create a note-taking system that seamlessly integrates with their development environment, enhancing productivity and knowledge retention.
Integrating Obsidian and Neovim
Setup Steps
- Install Neovim: Use a package manager to install Neovim on your system.
# macOS
brew install neovim
# Linux
sudo apt install neovim
# Windows
choco install neovim- Configure Neovim for Markdown: Enhance markdown editing with the Treesitter plugin by adding the following to
~/.config/nvim/init.lua(this is a minimalist config assuming you are starting from scratch…if you already have Lazy.nvim installed, you can just add the Treesitter plugin to your exisiting config):
-- Bootstrap lazy.nvim
local lazypath = vim.fn.stdpath("data") .. "/lazy/lazy.nvim"
if not (vim.uv or vim.loop).fs_stat(lazypath) then
local lazyrepo = "https://github.com/folke/lazy.nvim.git"
local out = vim.fn.system({ "git", "clone", "--filter=blob:none", "--branch=stable", lazyrepo, lazypath })
if vim.v.shell_error ~= 0 then
vim.api.nvim_echo({
{ "Failed to clone lazy.nvim:\n", "ErrorMsg" },
{ out, "WarningMsg" },
{ "\nPress any key to exit..." },
}, true, {})
vim.fn.getchar()
os.exit(1)
end
end
vim.opt.rtp:prepend(lazypath)
-- Initialize Lazy.nvim and setup plugins
require('lazy').setup({
-- Treesitter for syntax highlighting
{ 'nvim-treesitter/nvim-treesitter', run = ':TSUpdate' },
-- Load a color scheme that supports Treesitter
{
"folke/tokyonight.nvim",
lazy = false,
priority = 1000,
opts = {},
}
})
-- Treesitter configuration for Markdown
require'nvim-treesitter.configs'.setup {
ensure_installed = { "markdown", "markdown_inline" },
highlight = {
enable = true,
additional_vim_regex_highlighting = false,
},
}
-- Enable syntax highlighting
vim.cmd('syntax on')
-- Enable color scheme
vim.cmd[[colorscheme tokyonight]]- Install Neovim Obsidian Plugins: Use
obsidian.nvimandobsidian-bridge.nvimfor integration by adding the following to~/.config/nvim/init.lua:
-- A Neovim plugin for writing and navigating Obsidian vaults. Sane defaults...salt to taste
{
"epwalsh/obsidian.nvim",
version = "*", -- recommended, use latest release instead of latest commit
lazy = false,
ft = "markdown",
dependencies = {
"nvim-lua/plenary.nvim", -- Required dependency
},
config = function()
require("obsidian").setup({
workspaces = {
{ name = "personal", path = "~/Documents/notebooks/obsidian" },
--{ name = "work", path = "~/vaults/work", overrides = { notes_subdir = "notes" } },
},
notes_subdir = "__Inbox",
log_level = vim.log.levels.INFO,
daily_notes = {
folder = "__Inbox/dailies",
date_format = "%Y-%m-%d",
alias_format = "%B %-d, %Y",
default_tags = { "daily-notes" },
template = "Daily",
},
completion = {
nvim_cmp = true,
min_chars = 2,
},
mappings = {
["gf"] = {
action = function()
return require("obsidian").util.gf_passthrough()
end,
opts = { noremap = false, expr = true, buffer = true },
},
["ch"] = {
action = function()
return require("obsidian").util.toggle_checkbox()
end,
opts = { buffer = true },
},
-- Other Mappings
--[""] = {
-- action = function()
-- return require("obsidian").util.smart_action()
-- end,
-- opts = { buffer = true, expr = true },
--},
},
new_notes_location = "notes_subdir",
note_id_func = function(title)
local suffix = ""
if title ~= nil then
suffix = title:gsub(" ", "-"):gsub("[^A-Za-z0-9-]", ""):lower()
else
for _ = 1, 4 do
suffix = suffix .. string.char(math.random(65, 90))
end
end
return tostring(os.time()) .. "-" .. suffix
end,
note_path_func = function(spec)
local path = spec.dir / tostring(spec.id)
return path:with_suffix(".md")
end,
wiki_link_func = function(opts)
return require("obsidian.util").wiki_link_id_prefix(opts)
end,
markdown_link_func = function(opts)
return require("obsidian.util").markdown_link(opts)
end,
preferred_link_style = "wiki",
disable_frontmatter = false,
note_frontmatter_func = function(note)
if note.title then note:add_alias(note.title) end
local out = { id = note.id, aliases = note.aliases, tags = note.tags }
if note.metadata ~= nil and not vim.tbl_isempty(note.metadata) then
for k, v in pairs(note.metadata) do out[k] = v end
end
return out
end,
templates = {
folder = "__Resources/Templates/",
date_format = "%Y-%m-%d",
time_format = "%H:%M",
substitutions = {},
},
follow_url_func = function(url)
vim.fn.jobstart({"open", url}) -- Mac OS
end,
follow_img_func = function(img)
vim.fn.jobstart { "qlmanage", "-p", img } -- Mac OS quick look preview
end,
use_advanced_uri = false,
open_app_foreground = false,
picker = {
name = "telescope.nvim",
note_mappings = {
new = "",
insert_link = "",
},
tag_mappings = {
tag_note = "",
insert_tag = "",
},
},
sort_by = "modified",
sort_reversed = true,
search_max_lines = 1000,
open_notes_in = "current",
callbacks = {
post_setup = function(client) end,
enter_note = function(client, note) end,
leave_note = function(client, note) end,
pre_write_note = function(client, note) end,
post_set_workspace = function(client, workspace) end,
},
ui = {
enable = true,
update_debounce = 200,
max_file_length = 5000,
-- Find new Unicode glyphs at https://symbl.cc/en/
-- or https://www.nerdfonts.com/cheat-sheet
checkboxes = {
[" "] = { char = "", hl_group = "ObsidianTodo" },
["x"] = { char = "", hl_group = "ObsidianDone" },
[">"] = { char = "", hl_group = "ObsidianRightArrow" },
["~"] = { char = "", hl_group = "ObsidianTilde" },
["!"] = { char = "", hl_group = "ObsidianImportant" },
["i"] = { char = "", hl_group = "ObsidianInformation" },
},
bullets = { char = "•", hl_group = "ObsidianBullet" },
external_link_icon = { char = "", hl_group = "ObsidianExtLinkIcon" },
reference_text = { hl_group = "ObsidianRefText" },
highlight_text = { hl_group = "ObsidianHighlightText" },
tags = { hl_group = "ObsidianTag" },
block_ids = { hl_group = "ObsidianBlockID" },
hl_groups = {
ObsidianTodo = { bold = true, fg = "#f78c6c" },
ObsidianDone = { bold = true, fg = "#89ddff" },
ObsidianRightArrow = { bold = true, fg = "#f78c6c" },
ObsidianTilde = { bold = true, fg = "#ff5370" },
ObsidianImportant = { bold = true, fg = "#d73128" },
ObsidianInformation = { bold = true, fg = "#04a7ff" },
ObsidianBullet = { bold = true, fg = "#89ddff" },
ObsidianRefText = { underline = true, fg = "#c792ea" },
ObsidianExtLinkIcon = { fg = "#c792ea" },
ObsidianTag = { italic = true, fg = "#89ddff" },
ObsidianBlockID = { italic = true, fg = "#89ddff" },
ObsidianHighlightText = { bg = "#75662e" },
},
},
attachments = {
img_folder = "assets/imgs",
img_name_func = function()
return string.format("%s-", os.time())
end,
img_text_func = function(client, path)
path = client:vault_relative_path(path) or path
return string.format("", path.name, path)
end,
},
})
end,
},
-- Mirrors navigation events in Neovim in the Obsidian app leveraging the Local REST API
{
"oflisback/obsidian-bridge.nvim",
dependencies = { "nvim-telescope/telescope.nvim" },
config = function() require("obsidian-bridge").setup({
obsidian_server_address = "https://127.0.0.1:27124"
}) end,
event = {
"BufReadPre *.md",
"BufNewFile *.md",
},
lazy = true,
dependencies = {
"nvim-lua/plenary.nvim",
},
},
- Install Obsidian REST API Plugin: Navigate to the Community plugins section within the Obsidian app to locate and install the
Local REST API. Follow the instructions on the plugin wiki page (linked in the plugin information panel) to download and install the necessary SSL certificate. While in the plugin admin panel, make sure to copy your API key and set it as an environment variable for future use:
export OBSIDIAN_REST_API_KEY="xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"Synchronization Across Devices
Using Syncthing
Syncthing is a peer-to-peer synchronization tool that keeps your files updated across devices without relying on third-party servers. This approach is particularly important for sensitive information like personal notes, as it ensures your data remains private and under your control, without exposure to potential vulnerabilities associated with third-party servers.
- Install Syncthing: Install Syncthing on all your devices.
- Android: Syncthing-Fork is available on Google Play, and works reliably and as expected with other Syncthing nodes.
- iOS: Möbius Sync (two versions, one free and one paid) is available in the App Store, and reportedly works well with other Syncthing nodes (though I have not used it myself).
# macOS
brew install syncthing
# Linux
sudo apt install syncthing
# Windows
Download from the [Syncthing website](https://syncthing.net/downloads/)- Configuration: Use the web GUI to add your Obsidian vault folder and share it across devices.
- Connectivity: Ensure all devices are connected to the same network (Syncthing only works when the devices are connected via wifi).
Backup and Security
Secure Cloud Storage
For secure backups, choose a cloud storage provider like IDrive or pCloud that offers zero-knowledge encryption. Zero-knowledge encryption is crucial for protecting sensitive information, such as personal notes, because it ensures that only you have access to your data. The service provider cannot access your files, adding an extra layer of privacy and security.
- Setup: Install the cloud storage client and configure it to back up your Syncthing folder.
- Encryption: Enable encryption to protect your data.
Version Control with Git
While Obsidian offers built-in version control options, Git provides a more comprehensive layer of security and change tracking. This approach allows you to maintain a detailed history of your notes and store them safely on a remote server. Below is a straightforward method for pushing notes to a private GitHub repository. For those seeking enhanced control and security, consider GitLab self-hosting as an alternative to GitHub. This option provides complete data ownership but requires managing and maintaining the infrastructure, whether locally or in the cloud. For a deeper understanding of setting up a self-hosted GitLab instance, I recommend watching Christian Lempa’s informative video on the subject.
- Initialize Repository:
cd ~/path/to/your/vault
git init- .gitignore Configuration:
.obsidian/
.DS_Store- Commit and Push:
git add .
git commit -m "Update notes"
git remote add origin https://github.com/yourusername/your-repo.git
git push -u origin masterIt’s worth noting that implementing version control for your notes offers several benefits:
- The ability to track changes over time
- Easy collaboration with others (if desired)
- The option to revert to previous versions of your notes
- An additional layer of backup
Keep in mind that if you’re new to version control systems, there may be a learning curve with Git. However, the long-term benefits for managing and securing your notes often outweigh the initial time investment.
Complementary Approach: Second Brain and Bullet Journal
Traditionally, the Bullet Journal methodology has been an analog solution, celebrated for its simplicity and the tactile satisfaction of pen on paper. It’s a system that combines task management, journaling, and planning into one cohesive framework, offering users a way to track their daily lives and goals. However, as our lives become increasingly digital, the need for a more integrated approach to information management has grown. Enter tools like Obsidian, which allow us to leverage the Bullet Journal methodology in a digital format, either as an alternative to traditional analog note-taking or as a hybrid bridge between the two.
Concrete Ways to Blend the Two Approaches
- Task Management and Daily Logs: Use your Bullet Journal for daily task management, quick notes, and capturing fleeting thoughts. The tactile experience of writing can enhance memory retention and provide a sense of mindfulness. For tasks that require more detailed planning or are part of larger projects, transfer them to Obsidian. Use Obsidian’s linking capabilities to connect tasks with relevant notes and resources, creating a network of related information.
- Project Tracking and Research Compilation: Track progress on smaller projects and jot down initial ideas or inspiration in your Bullet Journal. Use it as a quick reference for ongoing tasks and deadlines. For large-scale projects, use Obsidian to compile research, reference materials, and detailed notes. Leverage the C.O.D.E. method—Capture, Organize, Distill, and Express—to systematically manage information and insights.
Obsidian’s bidirectional linking and graph view features transform your notes into a network of interconnected ideas, akin to a digital brain. This capability enhances the Bullet Journal methodology by allowing you to see relationships between tasks, projects, and research materials, providing a more holistic view of your commitments and ideas. Moreover, with plugins and themes, Obsidian can be customized to mirror the aesthetic and functional aspects of a traditional Bullet Journal, making the transition smoother for those new to digital note-taking.
Conclusion
By integrating Obsidian and Neovim, synchronizing with Syncthing, and securing your data with cloud storage and Git, you can build a robust second brain that enhances productivity and creativity. This system is not just about managing information—it’s about freeing your mind to focus on what truly matters.
By thoughtfully combining the Bullet Journal and Second Brain methodologies, you can create a powerful hybrid system that leverages the best of both worlds. This approach allows you to manage daily tasks and activities while maintaining a comprehensive repository of knowledge and ideas. It’s about finding the right balance and using each system for what it does best, resulting in a streamlined and efficient workflow.
Call to Action: Consider how you can integrate these methodologies into your life. Experiment with the tools and techniques mentioned, and tailor them to fit your unique needs and preferences. Your journey to a more organized and productive life starts now.
Please share your thoughts.