triliumnotes.org

An open-source UI element library is a collection of individual, ready-made interface pieces—buttons, cards, inputs, toggles, loaders—that you copy into your own project and adapt. A UI framework, by contrast, is a structured system of components, conventions, and often a theming layer that governs how your whole interface is built. The practical difference: an element library gives you a snippet; a framework gives you a way of working. If you need a polished button in ten minutes, reach for the element library. If you're building a 40-screen product with a team, you probably want the framework.

What "open-source UI element library" actually means

The term gets used loosely, so it helps to separate the parts:

• Open-source: the code is publicly available, and the license tells you what you may do with it—copy, modify, redistribute, or use commercially.
• UI element: a single, self-contained piece of interface, usually small enough to read in one sitting. A button with hover states, a pricing card, a search field.
• Library: a browsable, searchable collection of those elements, typically contributed by many different people.

On a site like Uiverse, elements are shared by a community and written in plain CSS or Tailwind. You find one you like, copy the markup and styles, paste them into your project, and adjust colors, spacing, and text to fit. There's no package to install and no build step required—which is exactly the appeal, and also the source of most of the confusion.

Element library vs. UI framework: the core differences

The table isn't a verdict. It's a map of trade-offs. Element libraries win on speed and freedom; frameworks win on consistency and maintenance.

Licensing and attribution: what to check before you paste

This is where people get into trouble, and it's worth slowing down for.

1. Find the license. Every element or collection should state one. Common open-source licenses include MIT, Apache-2.0, and BSD. Some projects use copyleft licenses like GPL, which can impose obligations if you redistribute your code.
2. Understand what the license permits. MIT and Apache-2.0 are permissive: you can typically use the code in commercial and closed-source projects. Copyleft licenses may require you to release derivative source under the same terms.
3. Check attribution requirements. Permissive licenses usually require you to keep the copyright notice and license text somewhere in your project. That's a real obligation, not a formality.
4. Look for per-element terms. On community sites, the site's overall terms and the individual contributor's stated wishes may differ. If a contributor asks for credit, honor it.
5. When in doubt, ask or avoid. If a snippet has no license at all, you don't have clear permission to reuse it. Treat "no license" as "not open source," even if the code is publicly visible.

This article is general information, not legal advice. For commercial products with real exposure, have someone qualified review the licenses you're relying on.

How to use a community element in your project: a practical workflow

Here's a repeatable process that avoids most of the usual mess.

1. Start from a real need, not a browsing session

Decide what you need first—"a compact primary button with a loading state"—then search. Browsing aimlessly produces a pile of pretty snippets that don't fit together.

2. Copy the smallest version that works

Take the markup and the styles. Strip anything you don't need: demo wrappers, extra animations, decorative layers. Less code means fewer surprises.

3. Convert it to your conventions

If your project uses design tokens or CSS variables, replace hard-coded values:

/* Before: hard-coded */
.button { background: #4f46e5; border-radius: 8px; }

/* After: token-based */
.button { background: var(--color-primary); border-radius: var(--radius-md); }

This one step is what keeps a copied element from looking like a foreign object in your UI.

4. Check accessibility before you ship

Community elements vary widely here. Verify at minimum:

• Keyboard focus is visible and the element is reachable by Tab.
• Color contrast meets WCAG AA (4.5:1 for normal text).
• Interactive elements use semantic HTML (<button>, not a clickable <div>).
• Form inputs have associated labels.
• Motion respects prefers-reduced-motion.

5. Test in context

Paste it into a real page with real content. Long labels, small screens, and dark mode break more copied elements than anything else.

6. Note where it came from

Keep a short comment or an internal credits file: source, license, date. Future you—and your legal reviewer—will be grateful.

Where element libraries genuinely shine

• Prototypes and demos: you need something clickable today, not a design system.
• Landing pages and marketing sites: a handful of distinctive elements, each custom.
• Filling gaps: your framework lacks one specific component, and you don't want to build it from scratch.
• Learning: reading well-made CSS is one of the fastest ways to improve.
• Small projects: a personal site doesn't need a theming architecture.

Where they fall short

• Consistency at scale: ten elements from ten contributors rarely look like one product.
• Maintenance: you own every copy. When your design changes, you edit each one.
• Accessibility debt: you inherit whatever the contributor did or didn't do.
• No upstream fixes: a bug fixed in the original won't reach your copy.
• Integration friction: different naming conventions, different units, different assumptions about resets.

When to choose which

Choose an element library when the scope is small, the timeline is short, or you need a few distinctive pieces rather than a whole system.

Choose a framework or design system when multiple people build multiple screens over months, when consistency is a product requirement, or when accessibility and theming need to be guaranteed rather than checked.

A hybrid works well for many teams: adopt a framework for the structural components—forms, navigation, layout—and borrow individual elements for the places where you want personality. Just route every borrowed element through the same token and accessibility checks, so it lands as part of your system rather than beside it.

The short version: open-source UI element libraries are a fast, flexible way to get good-looking interface pieces into a project. They are not a substitute for a design system, and the license and accessibility details are the part worth reading carefully.

Trilium Notes supports a range of note types for different kinds of content, plus power features such as fuzzy search with OCR, automatic note revisions, password-protected encrypted notes, reusable templates, a web clipper, public read-only note sharing, and a built-in REST API. These capabilities are available in the open-source app, which runs locally on your desktop or syncs with a self-hosted server. No account is needed and it works offline, so the features below apply whether you use it standalone or with a server.

Note types for every kind of content

Trilium's own materials frame note types as the answer to the fact that "not everything fits neatly into a paragraph." Rather than forcing all content into one editor, the app lets you pick a type per note. The site groups this under "A note type for every kind of content," though the excerpt cuts off before listing each type individually. In practice, this means you can keep prose notes alongside structured or specialized content in the same tree, choosing the format that fits each piece.

How note structure works alongside note types

Note types sit on top of a folder-free hierarchy:

• Hierarchical notes: Each note can contain sub-notes, so no folders are required.
• Multiple placements: A single note can appear in more than one place in the hierarchy.
• Labels and relations: Add labels for categorization or relations between notes; promoted attributes turn structured information into tables and boards.
• Workspaces and hoisting: Group notes under a workspace to focus the tree on a specific set of notes, separating personal and work material.

This structure matters for note types because a single note—whatever its type—can be reused across contexts without duplication.

Search and navigation

• Fuzzy quick navigation: Jump to any note or command by title using fuzzy matching.
• Full-text search: Search across your notes, including text inside images and PDFs via OCR.

The OCR support is the notable part: scanned documents and screenshots become searchable without manual transcription.

Revisions and protected notes

• Note revisions: Notes are periodically saved in the background, and revisions can be used to review or undo accidental changes. You can also create revisions on demand.
• Protected notes: Sensitive information can be encrypted and locked behind a password-protected session.

Revisions give you a safety net for edits; protected notes give you a way to keep private material in the same knowledge base without exposing it.

Templates, clipping, and sharing

Two conditions are worth noting: public sharing and the sign-in options depend on running a server, while the clipper depends on the browser extension. The REST API is described as built-in.

Choosing based on what you need

• If you want one tool for mixed content: the range of note types plus labels, relations, and promoted attributes covers prose, structured data, and tables/boards.
• If you work with scanned material: OCR search inside images and PDFs is the deciding feature.
• If you need privacy within one knowledge base: protected notes and revisions cover both confidentiality and recovery.
• If you want to publish or automate: plan on a self-hosted server for public sharing and secure sign-in, and use the REST API for integrations.

For setup specifics—such as which note types exist and how to enable each feature—check the Trilium documentation and GitHub repository referenced on the site.

Trilium Notes syncs through a server instance you run yourself or use in the cloud, and you reach your notes on a phone through a Progressive Web App (PWA) that connects to that server. Local desktop use needs no account and works offline, but syncing across devices and mobile access both depend on having a server available. If you only ever use one computer, you can skip the server entirely.

The two ways to run Trilium

The project describes itself as usable locally on your desktop or synced with a self-hosted server "to keep your notes everywhere you go." The server is the hub: devices sync to it rather than to each other directly.

How syncing works in practice

1. Set up the server instance. Run Trilium on a machine you control (self-hosted) or on a cloud instance. This instance holds the shared copy of your notes.
2. Connect each device to it. Point your desktop clients at the server so changes flow both ways.
3. Work as usual. Notes are periodically saved in the background, and revisions can be reviewed or used to undo accidental changes. Revisions can also be created on demand.

The practical consequence: the server must be reachable for sync to happen. A desktop that has been offline keeps working locally, but its changes only reach other devices once it can talk to the server again.

Mobile access through a PWA

On a phone, you don't install a separate native app from the project's site — you open the server's web interface and add it to your home screen as a PWA. From there it behaves like an app: you browse and edit notes that live on the server.

This means mobile access inherits the server's availability. If the server is down or unreachable, the phone can't load your notes. It also means the server's sign-in settings are what protect your notes on mobile.

Sign-in and security on the server

Because the server is the front door to your notes, Trilium offers two ways to secure it:

• Multi-factor authentication (TOTP) — add a time-based one-time code on top of your password.
• OpenID Connect — sign in through your identity provider instead of managing a separate password.

For sensitive content, individual notes can also be encrypted and locked behind a password-protected session. That protection travels with the note, so it applies wherever you open it.

What you can do once synced

A server unlocks more than sync:

• Publish a read-only website. Any subtree of your notes can be published as a public site that anyone can browse without an account.
• Use the REST API. Read, create, and update notes over HTTP for automations and third-party integrations.
• Clip from the browser. The web clipper extension grabs pages or screenshots and places them directly into Trilium.

Choosing your setup

• Pick local-only if your notes live on one machine and you don't need them on a phone. It's the simplest path and needs no account.
• Pick a self-hosted server if you want sync, mobile access, publishing, and API access while keeping the data on hardware you control. You take on running and securing that machine.
• Pick a cloud instance if you want the same features without maintaining a server, accepting that the instance is hosted elsewhere.

Whichever you choose, the note structure stays the same: notes are arranged hierarchically with sub-notes instead of folders, and a single note can appear in multiple places in the tree. That structure is what syncs — so organizing on your desktop shows up the same way on your phone.

Trilium Notes is an open-source note-taking and personal knowledge base application. You can run it locally on your desktop, or sync it with a self-hosted server to keep your notes available across devices. It is designed for people who want to organize thoughts, build a structured personal knowledge base, and keep control of their data. No account is needed, and it works offline. It is also sometimes searched for as "Trillium Notes."

Who It Is For

Trilium Notes fits people who want more structure than a flat list of notes but do not want to be locked into a proprietary cloud service. Because it is open-source and can run locally, it suits users who value data ownership and offline access. If you need to access notes from multiple devices, you can set up a self-hosted or cloud instance for synchronization.

How Notes Are Organized

Trilium uses a hierarchical note structure rather than folders. Each note can contain sub-notes, and a single note can appear in multiple places in the hierarchy. This means the same note can belong to more than one context without duplication.

Beyond hierarchy, you can:

• Use labels and relations to categorize notes and connect them to each other.
• Use promoted attributes to enter structured information that can feed into tables and boards.
• Group notes into workspaces to separate personal and work notes, focusing the note tree on a specific set of notes.
• Hoist notes to focus on a particular subtree.

Everyday Features

Trilium includes features for day-to-day note work:

Note Types and Content

Not everything fits into a paragraph, so Trilium offers a range of note types for different kinds of content. The site lists "a note type for every kind of content" as a core capability, alongside import and export, collections, and scripting. This makes it usable for mixed content—text notes, structured data, and more—within one knowledge base.

Data Ownership and Portability

The site states that "your notes are never locked in," and Trilium is AGPL-3.0 licensed. Combined with local operation and self-hosted sync, this means you are not dependent on a vendor account to access your notes. You can also import and export content, which helps if you want to move data in or out.

When to Choose Trilium Notes

Choose Trilium if you want:

• A hierarchical, flexible note structure without rigid folders.
• Offline-first use with optional self-hosted sync.
• Open-source software with no required account.
• Features like scripting, a REST API, and web publishing for deeper customization.

If you only need a simple cloud-synced notes app and do not want to manage a server, the self-hosted sync path may be more setup than you need. But for users who want a personal knowledge base they control, Trilium is built around that goal.

Trilium Notes replaces folders with a hierarchical tree of notes: any note can contain sub-notes, so the note itself acts as the container. The same note can also appear in more than one place in the tree, so a single piece of content doesn't have to be duplicated to live under two topics. This suits people building a personal knowledge base who want structure without maintaining a separate folder scheme, and it works whether you run Trilium locally on a desktop or sync it with a self-hosted server.

The note tree is the structure

In a folder-based system, structure lives outside the content: you create a folder, then put files in it. In Trilium, structure and content are the same object. A note about a project can hold sub-notes for meeting records, reference links, and drafts, and those sub-notes can hold their own children. There is no separate folder layer to keep in sync with what you actually wrote.

The practical consequence is that you can start writing first and organize later. Create a note, then decide where it belongs by placing it in the tree.

One note, multiple locations

A note can be added in multiple places in the hierarchy. This is the feature that most directly replaces the workarounds people use with folders — shortcuts, duplicate copies, or "see also" links.

For example, a note on a research paper could sit under both a "Reading list" branch and a "Project X sources" branch. Editing it once updates it everywhere it appears, because it is one note with several placements rather than several copies.

Labels, relations, and promoted attributes

Beyond position in the tree, Trilium adds metadata to notes:

• Labels attach categories or tags to a note for grouping and filtering.
• Relations connect one note to another by name, which is useful when the connection isn't parent-child.
• Promoted attributes let you enter structured information on a note and then use that information in tables and boards.

The distinction matters: the tree answers "where does this live," while labels and relations answer "what is this and what does it relate to." A note can be filed in one place but tagged and linked across many.

Workspaces and hoisting keep large trees manageable

A deep tree becomes noisy once it holds both personal and work material. Trilium addresses this in two ways:

• Workspaces group notes so that the tree shows only a specific set of notes — for example, separating personal notes from work notes.
• Hoisting focuses the tree on a chosen note and its descendants, so you work inside one branch without the rest of the tree in view.

Use workspaces when you want a persistent split between contexts, and hoisting when you want a temporary focus on one part of the tree.

What this means for choosing Trilium

The trade-off is that a note-tree model asks you to think about placement and metadata rather than dropping files into folders. If you prefer a strict single-location filing system, folders may feel simpler; if you keep returning to the same notes from different contexts, the multi-placement and labeling model removes the duplication.

To try it, start with a single branch for one active project, add sub-notes as the work grows, and add a label or relation only when you notice yourself wanting the same note in a second place.