app
Think fearlessly with end-to-end encrypted notes and files. For issues, visit https://standardnotes.com/forum or https://standardnotes.com/help.
Top Related Projects
A privacy-first, open-source platform for knowledge management and collaboration. Download link: http://github.com/logseq/logseq/releases. roadmap: http://trello.com/b/8txSM12G/roadmap
Joplin - the privacy-focused note taking app with sync capabilities for Windows, macOS, Linux, Android and iOS.
A personal knowledge management and sharing system for VSCode
A plain text note-taking assistant
Quick Overview
Standard Notes is an open-source, end-to-end encrypted notes app that prioritizes user privacy and data security. It offers a clean, distraction-free interface for note-taking across multiple platforms, including web, desktop, and mobile devices.
Pros
- Strong focus on privacy and security with end-to-end encryption
- Cross-platform compatibility (web, desktop, and mobile)
- Extensible architecture with support for themes and editors
- Regular updates and active community support
Cons
- Some advanced features require a paid subscription
- Learning curve for setting up self-hosted instances
- Limited integration with third-party services due to privacy focus
- Sync conflicts can occasionally occur in offline mode
Getting Started
To get started with Standard Notes:
- Visit the official website: https://standardnotes.com/
- Download the app for your preferred platform (Web, Desktop, or Mobile)
- Create a new account or sign in with an existing one
- Start creating encrypted notes and organizing your thoughts securely
For developers interested in contributing or self-hosting:
- Clone the repository:
git clone https://github.com/standardnotes/app.git - Install dependencies:
cd app yarn install - Run the development server:
yarn start
For more detailed instructions, refer to the project's README and documentation on GitHub.
Competitor Comparisons
A privacy-first, open-source platform for knowledge management and collaboration. Download link: http://github.com/logseq/logseq/releases. roadmap: http://trello.com/b/8txSM12G/roadmap
Pros of Logseq
- Open-source knowledge management and collaboration platform
- Supports local-first, plain text storage (Markdown/Org-mode)
- Advanced features like graph view and bidirectional linking
Cons of Logseq
- Steeper learning curve due to its outliner-based structure
- Less focus on end-to-end encryption compared to Standard Notes
- Limited mobile app functionality (as of the last update)
Code Comparison
Logseq (ClojureScript):
(defn get-block-property [block property-name]
(when-let [properties (:block/properties block)]
(get properties property-name)))
Standard Notes (JavaScript):
export function getItemAppDataValue(item, key) {
const data = item.content.appData[COMPONENT_MANAGER_KEY];
return data && data[key];
}
Both projects use different programming languages, reflecting their distinct architectures. Logseq's code snippet demonstrates property retrieval from a block, while Standard Notes' code focuses on accessing app data from an item. This highlights Logseq's block-based structure versus Standard Notes' more traditional note-taking approach.
Joplin - the privacy-focused note taking app with sync capabilities for Windows, macOS, Linux, Android and iOS.
Pros of Joplin
- More feature-rich, including support for Markdown formatting and attachments
- Open-source and self-hostable, offering greater control over data
- Cross-platform compatibility with desktop, mobile, and terminal applications
Cons of Joplin
- Slightly more complex user interface, which may be less intuitive for some users
- Sync process can be slower, especially with large numbers of notes or attachments
- Less emphasis on simplicity and minimalism compared to Standard Notes
Code Comparison
Joplin (JavaScript):
const Note = require('lib/models/Note.js');
const Folder = require('lib/models/Folder.js');
async function createNote(title, body, parentId) {
const note = await Note.save({ title: title, body: body, parent_id: parentId });
return note;
}
Standard Notes (Ruby):
class Note < ApplicationRecord
belongs_to :user
has_many :tags, through: :taggings
def create_and_tag(title, text, tag_names)
note = user.notes.create(title: title, text: text)
note.tag_with(tag_names)
note
end
end
Both projects use different programming languages and architectures, making direct code comparison challenging. However, these snippets illustrate basic note creation functionality in each application.
A personal knowledge management and sharing system for VSCode
Pros of Foam
- Open-source and highly customizable, allowing for extensive user modifications
- Seamlessly integrates with Visual Studio Code, leveraging its powerful features
- Supports graph visualization for better understanding of note connections
Cons of Foam
- Steeper learning curve, especially for users unfamiliar with VS Code
- Less polished user interface compared to Standard Notes
- Requires more manual setup and configuration
Code Comparison
Foam (TypeScript):
export function createMarkdownParser(
workspace: IWorkspace,
linkReferenceDefinitionProvider: LinkReferenceDefinitionProvider
): MarkdownParser {
return new MarkdownParser(workspace, linkReferenceDefinitionProvider);
}
Standard Notes (JavaScript):
export default class Editor extends React.Component {
constructor(props) {
super(props);
this.state = {
noteContent: this.props.note.content,
};
}
}
Foam focuses on creating a markdown parser for note processing, while Standard Notes implements a React component for the editor interface. Foam's code reflects its integration with VS Code and emphasis on markdown handling, whereas Standard Notes' code showcases its web-based, React-driven approach to note editing.
A plain text note-taking assistant
Pros of zk
- Focused on Zettelkasten note-taking method, offering specialized features for this approach
- Command-line interface provides quick and efficient note management
- Supports multiple markup languages (Markdown, Org-mode, etc.)
Cons of zk
- Limited cross-platform support (primarily for Unix-like systems)
- Lacks a graphical user interface, which may be less intuitive for some users
- Fewer built-in synchronization and encryption options compared to Standard Notes
Code Comparison
zk (Rust):
pub fn new_note(content: &str, title: Option<&str>) -> Result<Note> {
let id = Uuid::new_v4().to_string();
let created = Utc::now();
let modified = created;
// ...
}
Standard Notes (JavaScript):
createNote(params) {
this.notes.push({
uuid: this.crypto.generateUUID(),
content: params.content,
created_at: new Date(),
updated_at: new Date(),
// ...
});
}
Both projects implement note creation with unique identifiers and timestamps, but zk uses Rust's strong typing and error handling, while Standard Notes opts for a more flexible JavaScript approach.
Convert 
designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual CopilotREADME
Standard Notes
Standard Notes is an end-to-end encrypted note-taking app for digitalists and professionals. Capture your notes, files, and lifeâs work all in one secure place.
Why Standard Notes?
- End-to-end encrypted sync. Only you can read your notes.
- Fast, free, and encrypted cross-platform sync on unlimited devices.
- Public source code with ability to self-host your own server in a few easy steps.
- A strong focus on longevity and sustainability. Learn more.
Creating your private notes account
- Launch the web app at app.standardnotes.com.
- Click Register to create your private notes account.
- Download Standard Notes on your devices.
- You're all set. Standard Notes comes out of the box with end-to-end encrypted sync on all your devices.
Publish a Blog
Standard Notes is a dependable environment to do your most important work, including publishing your ideas to the world. Listed allows you to create an online publication with automatic email newsletters delivered to your readers, directly from Standard Notes.
Community
Join us on
Developers can create and publish their own extensions. Visit the documentation hub to learn more.
Questions? Find answers on our Help page.
Self-hosting the web app
Our web app is compiled into a folder of static HTML, JS, and CSS files. You can serve these files behind a web server to get started:
git clone https://github.com/standardnotes/app.gitcd appyarn installyarn build:webcd packages/web- You can then use Python to serve this folder over http:
python -m http.server 8080
You can now access the app at http://localhost:8080.
Running Web App in Development Mode
- Clone the repo
yarn installyarn build:webcd packages/web && yarn start- Open your browser to
http://localhost:3001.
You can configure the DEFAULT_SYNC_SERVER environment variable to set the default server for login and registration.
DEFAULT_SYNC_SERVER=https://sync.myserver
Top Related Projects
A privacy-first, open-source platform for knowledge management and collaboration. Download link: http://github.com/logseq/logseq/releases. roadmap: http://trello.com/b/8txSM12G/roadmap
Joplin - the privacy-focused note taking app with sync capabilities for Windows, macOS, Linux, Android and iOS.
A personal knowledge management and sharing system for VSCode
A plain text note-taking assistant
Convert designs to code with AI
Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.
Try Visual Copilot