Next Up: Pillar

Written by Finn Williams

•

April 21, 2025
announcement

What is Pillar?

Pillar is an open-source, free-to-use note-taking application currently in development by Voithos Labs. It’s local-first (no account required), extendable, and built to organize anything from a few notes to hundreds of thousands.

Why?

Let's get straight to the meat of it. We're working on this because no existing application satisfies our note-taking needs sufficiently.

Here’s a quick breakdown of what's good and bad about a few popular options today:

Obsidian

Good

  • Local-first, Free to Use: Everything is stored as .md files on your device. You own your data, no vendor lock-in, free to download.

  • Extendable: Massive community plugin ecosystem. There are extensions for everything from spaced repetition to custom canvases.

Bad

  • Lackluster Editor: The editing experience is still Markdown-first. "Live Preview" is a compromise, not a full rich text editor. Not everyone likes markdown. Not everyone who likes markdown uses it all the time.

  • Closed Source: A vibrant plugin community props up a closed-core app. Devs contribute for free—control and monetization stay locked behind the vendor.

  • Dependency on Plugins: Basic out-of-the-box features are limited. You’ll often find yourself stitching together plugins to make it usable for your workflow.

  • No Version History: Without plugins or a paid plan, you get only basic undo/redo.

  • No Peer Collaboration

  • Paid Cloud Sync

Notion

Good

  • Polished Editing Experience: Clean, modern UI—if a little busy.

  • Highly Customizable Workflows: Notion shines when you're building a very specific system -- databases, dashboards, project templates, etc.

  • Collaboration Ready: Real-time multiplayer editing, inline comments, and permission controls make it decent for small teams.

Bad

  • Freemium Pressure: You’ll quickly feel the push toward paid tiers. Version history, guest limits, and API usage limits add up.

  • Overwhelming Setup: There's a paradox here -- Notion is customizable but not usable out of the box. You often have to spend hours building the thing before it's useful.

  • Cloud-Only & Proprietary: You don’t own your data. Exports are lossy. Full vendor lock-in.

  • Ultra Bloated: Features aimed at full-scale project management—OKRs, CRMs—when most users just want decent notes.

OneNote

Good

  • Drawing/Handwriting Support: Great if you’re on a tablet. Good if you have a drawing pad.

Bad

  • Unstructured: Freeform canvas layout is good for sketches, bad for organized notes.

  • Buggy/Bloated: Sync issues, inconsistent UI, frequent crashes.

  • Weak Search/Navigation: Especially painful with large notebooks.

  • Microsoft Lock-in: Integrates tightly with Office. This is never a good thing.

So, what makes a note-taking app good?

From our experience, here’s what actually matters:

  • Free, local-first, and open-source

  • Simple, modern UI with real customization

  • Extendable and scriptable

  • Supports collaboration, sync, and version history

  • Runs everywhere

This is the foundation for Pillar.

The Big List

Sample of features coming to Pillar:

  • Atomic Content Blocks (ACBs): Rich, highly-extendible, structured blocks with Markdown/LaTeX compatibility and visual elements—todo lists, graphs, drawings, calendars, code. Interchangeable with LaTeX and Markdown, PDF export support, and backed by reusable web components.
    → We’ll cover the ACB system in more detail in an upcoming post.

  • Note Organization: Pillar uses a flexible system based on groups internally, combining traditional folder hierarchies and tag-based classification. Support for organic organization using configurable semantic analysis to group related content naturally over time.

  • Executable Code Blocks: Run code directly inside notes using local runtimes. Think Jupyter, but more flexible with support for: C/C++, Rust, Java, R [+vis], Python [+vis], Julia [+vis], JS/TS [+vis], C#, Go
    [+vis] = supports built-in graph/plot output. Add any language runnable locally.

  • Peer Collaboration: both live and minimal-branching for offline collaborative editing support.

  • Material Ingestion: import PDFs, text files, Google Docs, and more with immediate support for search and AI assistant retrieval.

  • Import Support: Bring in existing note collections, Markdown exports, LaTeX projects, or random directories.

  • Appearance Customization: Colors, themes, fonts, symbols—change everything.

  • Internal Linking: Notes link organically as you write.

  • And more, follow the blog!

And of course:

  • Good Multilingual Text-to-Speech, available with cloud and local model support.

  • Good Speech-to-Text, using local Whisper with lean LLM postprocessing for increased accuracy. Available both locally and with cloud services for older devices.

  • Good Search, extremely fast even across hundreds of thousands of notes. Support for title search, content search, and semantic searching.

AI Integration (buzzword trigger warning)

Most modern app AI integrations are clunky and pretty terrible. It is not something that can just be tacked onto an existing application in a useful and intuitive manner without some thought.

In real use, the best parts of LLM-powered tools like ChatGPT are things like search, summarization, and proofreading—not writing your notes for you.

So, here's how we’re doing it:

Housekeeping (passive, configurable)

These are the “small magic” features—tidy up notes, check grammar, create links, and keep everything organized. It all runs locally via Ollama, and it’s embedded in the UI—no chat windows or popups.

Retrieval-Enhanced Chat (active)

Yep, an AI chat (boring). But it’s powered by local RAG and internet search. Ask questions about your own notes, generate citations, or fact-check in real time. Invisible until you need it.

Quick Actions / In-Line (active, accessibility-focused)

Scoped in-line utilityy, e.g.:

  • @ plot '2025_NA-climate-date.csv' with a trend line

  • @ add https://arxiv.org/abs/2504.13996 to bibliography

    Quick actions support assisted navigation and organization. Simple, intuitive, and there when you need them.

“Active” = user-triggered (e.g., shortcut or click).
“Passive” = automatic support in the background.

There is a real and practical place for LLMs in accessibility, tools that understand you. This is the area we're exploring AI integration in the most depth. Things like hands-free navigation and use, guided note taking, and material ingestion.

Pillar Data Structure (for nerds)

Groups
├── Flexible organization system
├── Combines:
│   ├── Folder-based hierarchy (can mirror filesystem)
│   └── Tag-based classification (overlapping, supersets hierarchy)
├── Supports automatic semantic grouping (configurable)
└── Represents a group of documents
    └── Documents
        ├── Markdown files
        ├── LaTeX documents
        ├── PDFs
        ├── Plaintext files (e.g., code, CSVs)
        ├── External documents (e.g., Google Docs)
        └── ACB documents
            └── Blocks (ACBs)
                ├── Atomic, modular content units
                ├── Rendered by standalone web components
                ├── Highly extensible
                └── Exportable to Markdown, PDF, LaTeX

Thanks for reading!
Pillar is still in active development—if this sounds like something you’d use (or help build), we’d love to hear from you. More blogs soon! (And public forum)

→ contact@voithoslabs.com

→ voithoslabs.com/blog