Convert Figma logo to code with AI

AppFlowy-IO logoAppFlowy

Bring projects, wikis, and teams together with AI. AppFlowy is an AI collaborative workspace where you achieve more without losing control of your data. The best open source alternative to Notion.

55,119
3,601
55,119
926

Top Related Projects

31,960

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

Community plugins list, theme list, and releases of Obsidian.

5,241

Think fearlessly with end-to-end encrypted notes and files. For issues, visit https://standardnotes.com/forum or https://standardnotes.com/help.

15,215

A personal knowledge management and sharing system for VSCode

6,315

Athens is no longer maintainted. Athens was an open-source, collaborative knowledge graph, backed by YC W21

Quick Overview

AppFlowy is an open-source alternative to Notion, designed to be a powerful and customizable productivity tool. It allows users to create documents, databases, and workflows with a user-friendly interface, while maintaining control over their data through self-hosting options.

Pros

  • Open-source and self-hostable, providing users with full control over their data
  • Cross-platform support (Windows, macOS, Linux, and mobile platforms)
  • Highly customizable and extensible through plugins and themes
  • Active community and regular updates

Cons

  • Still in early development stages, may have stability issues
  • Limited features compared to more established alternatives like Notion
  • Self-hosting requires technical knowledge and resources
  • Documentation may be incomplete or outdated in some areas

Getting Started

To get started with AppFlowy:

  1. Visit the AppFlowy GitHub repository
  2. Follow the installation instructions for your platform:
    • For desktop: Download the latest release from the releases page
    • For mobile: Download from the App Store or Google Play Store
  3. Launch AppFlowy and create your first workspace
  4. Explore the available features and start organizing your data

For developers interested in contributing:

  1. Fork the repository
  2. Clone your fork: git clone https://github.com/your-username/AppFlowy.git
  3. Set up the development environment following the instructions in the CONTRIBUTING.md file
  4. Make your changes and submit a pull request

Competitor Comparisons

31,960

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

  • Built-in graph view for visualizing connections between notes
  • Supports both Markdown and Org-mode syntax
  • Offline-first approach with local storage and optional sync

Cons of Logseq

  • Steeper learning curve due to its unique structure and features
  • Limited customization options for UI and themes compared to AppFlowy

Code Comparison

Logseq (ClojureScript):

(defn get-block-by-id
  [id]
  (when id
    (db/entity [:block/uuid (uuid id)])))

AppFlowy (Rust):

pub fn get_block_by_id(&self, id: &str) -> Option<Block> {
    self.blocks.get(id).cloned()
}

Both projects aim to provide note-taking and knowledge management solutions, but they differ in their approach and implementation. Logseq focuses on a graph-based, outliner-style interface, while AppFlowy offers a more traditional document-centric approach with additional features like databases and kanban boards.

AppFlowy is built with Flutter and Rust, providing a native cross-platform experience, while Logseq uses ClojureScript and Electron. This difference in technology stacks impacts performance and resource usage, with AppFlowy potentially offering better performance on resource-constrained devices.

Both projects are open-source and actively maintained, with strong community support and regular updates. The choice between them largely depends on personal preferences and specific use cases.

Community plugins list, theme list, and releases of Obsidian.

Pros of Obsidian-releases

  • Mature and widely adopted note-taking application with a large user base
  • Extensive plugin ecosystem for customization and extended functionality
  • Supports local file storage and offline usage

Cons of Obsidian-releases

  • Closed-source software, limiting community contributions to core functionality
  • Primarily focused on personal knowledge management, less suitable for collaborative work
  • Limited built-in project management features

Code Comparison

While a direct code comparison is not possible due to Obsidian being closed-source, we can compare some aspects of their plugin systems:

AppFlowy (Rust):

#[pg_extern]
fn hello_appflowy() -> String {
    "Hello, AppFlowy!".to_string()
}

Obsidian (JavaScript):

module.exports = {
  onload: function() {
    console.log("Hello, Obsidian!");
  }
};

AppFlowy uses Rust for its core functionality, providing better performance and memory safety. Obsidian's plugin system is based on JavaScript, offering easier development for a wider range of developers but potentially sacrificing some performance.

AppFlowy aims to be an open-source alternative to Notion, focusing on collaborative work and project management. Obsidian, on the other hand, excels in personal knowledge management and note-taking with a strong emphasis on local file storage and linking between notes.

5,241

Think fearlessly with end-to-end encrypted notes and files. For issues, visit https://standardnotes.com/forum or https://standardnotes.com/help.

Pros of Standard Notes

  • Longer development history and more mature codebase
  • Cross-platform support (web, desktop, and mobile)
  • Strong focus on end-to-end encryption and privacy

Cons of Standard Notes

  • Less visually appealing interface compared to AppFlowy
  • Limited collaboration features
  • Steeper learning curve for advanced features

Code Comparison

Standard Notes (JavaScript):

export function decryptString(base64EncryptedString, key) {
  const encryptedBytes = base64ToArrayBuffer(base64EncryptedString);
  return crypto.subtle.decrypt({ name: 'AES-GCM', iv: this.iv }, key, encryptedBytes)
    .then(decrypted => arrayBufferToString(decrypted));
}

AppFlowy (Rust):

pub fn encrypt_text(text: &str, key: &[u8]) -> Result<Vec<u8>, Error> {
    let nonce = Nonce::from_slice(b"unique nonce");
    let cipher = Aes256Gcm::new(Key::from_slice(key));
    cipher.encrypt(nonce, text.as_bytes().as_ref())
        .map_err(|e| Error::EncryptionError(e.to_string()))
}

Both repositories implement encryption functions, but AppFlowy uses Rust for better performance and memory safety, while Standard Notes opts for JavaScript for wider compatibility across platforms.

15,215

A personal knowledge management and sharing system for VSCode

Pros of Foam

  • Lightweight and flexible, integrating seamlessly with VS Code
  • Strong focus on knowledge management and note-linking
  • Extensive plugin ecosystem leveraging VS Code extensions

Cons of Foam

  • Less feature-rich compared to AppFlowy's all-in-one solution
  • Steeper learning curve for users unfamiliar with VS Code
  • Limited built-in collaboration features

Code Comparison

Foam (JavaScript):

export async function createNoteFromTemplate(
  templatePath: string,
  destinationPath: string,
  variables: { [key: string]: string }
): Promise<void> {
  // Implementation details
}

AppFlowy (Rust):

pub async fn create_document(
    &self,
    name: &str,
    parent_id: &str,
) -> Result<Document, FlowyError> {
    // Implementation details
}

The code snippets showcase different approaches to document creation. Foam's JavaScript function focuses on creating notes from templates with variable substitution, while AppFlowy's Rust function emphasizes a more straightforward document creation process within a hierarchical structure.

6,315

Athens is no longer maintainted. Athens was an open-source, collaborative knowledge graph, backed by YC W21

Pros of Athens

  • Built with Clojure, offering a unique and powerful functional programming approach
  • Focuses on networked thought and knowledge graphs, ideal for complex interconnected ideas
  • Emphasizes local-first architecture, ensuring data privacy and offline functionality

Cons of Athens

  • Smaller community and less frequent updates compared to AppFlowy
  • Limited cross-platform support, primarily focused on desktop environments
  • Steeper learning curve due to its unique approach and Clojure-based architecture

Code Comparison

Athens (Clojure):

(defn create-page [title]
  (let [uid (gen-uid)]
    {:block/uid uid
     :node/title title
     :block/children []}))

AppFlowy (Rust):

pub fn create_page(title: String) -> Page {
    Page {
        id: Uuid::new_v4(),
        title,
        children: Vec::new(),
    }
}

Both examples demonstrate page creation, but Athens uses Clojure's functional style with immutable data structures, while AppFlowy employs Rust's more traditional object-oriented approach with mutable structs.

Convert Figma logo designs to code with AI

Visual Copilot

Introducing Visual Copilot: A new AI model to turn Figma designs to high quality code using your components.

Try Visual Copilot

README

AppFlowy.IO
⭐️ The Open Source Alternative To Notion ⭐️

AppFlowy is the AI workspace where you achieve more without losing control of your data

License: AGPL

Website • Forum • Discord • Reddit • Twitter

AppFlowy Kanban Board for To-dos

AppFlowy Databases for Tasks and Projects

AppFlowy Sites for Beautiful documentation

AppFlowy AI

AppFlowy Templates



Work across devices

Work across devices

Work across devices

User Installation

Built With

Stay Up-to-Date

AppFlowy Github - how to star the repo

Getting Started with development

Please view the documentation for OS specific development instructions

Roadmap

If you'd like to propose a feature, submit a feature request here
If you'd like to report a bug, submit a bug report here

Releases

Please see the changelog for more details about a given release.

Contributing

Contributions make the open-source community a fantastic place to learn, inspire, and create. Any contributions you make are greatly appreciated. Please look at Contributing to AppFlowy for details.

If your Pull Request is accepted as it fixes a bug, adds functionality, or makes AppFlowy's codebase significantly easier to use or understand, Congratulations! If your administrative and managerial work behind the scenes sustains the community, Congratulations! You are now an official contributor to AppFlowy. Get in touch with us (link) to receive the very special Contributor T-shirt! Proudly wear your T-shirt and show it to us by tagging @appflowy on Twitter.

Translations 🌎🗺

translation badge

To add translations, you can manually edit the JSON translation files in /frontend/resources/translations, use the inlang online editor, or run npx inlang machine translate to add missing translations.

Join the community to build AppFlowy together

Why Are We Building This?

Notion has been our favourite project and knowledge management tool in recent years because of its aesthetic appeal and functionality. Our team uses it daily, and we are on its paid plan. However, as we all know, Notion has its limitations. These include weak data security and poor compatibility with mobile devices. Likewise, alternative collaborative workplace management tools also have their constraints.

The limitations we encountered using these tools and our past work experience with collaborative productivity tools have led to our firm belief that there is a glass ceiling on what's possible for these tools in the future. This emanates from the fact that these tools will probably struggle to scale horizontally at some point and be forced to prioritize a proportion of customers whose needs differ from the rest. While decision-makers want a workplace OS, it is impossible to come up with a one-size fits all solution in such a fragmented market.

When a customer's evolving core needs are not satisfied, they either switch to another or build one from the ground up, in-house. Consequently, they either go under another ceiling or buy an expensive ticket to learn a hard lesson. This is a requirement for many resources and expertise, building a reliable and easy-to-use collaborative tool, not to mention the speed and native experience. The same may apply to individual users as well.

All these restrictions necessitate our mission - to make it possible for anyone to create apps that suit their needs well.

  • To individuals, we would like to offer Notion's functionality, data security, and cross-platform native experience.
  • To enterprises and hackers, AppFlowy is dedicated to offering building blocks and collaboration infra services to enable you to make apps on your own. Moreover, you have 100% control of your data. You can design and modify AppFlowy your way, with a single codebase written in Flutter and Rust supporting multiple platforms armed with long-term maintainability.

We decided to achieve this mission by upholding the three most fundamental values:

  • Data privacy first
  • Reliable native experience
  • Community-driven extensibility

We do not claim to outperform Notion in terms of functionality and design, at least for now. Besides, our priority doesn't lie in more functionality at the moment. Instead, we would like to cultivate a community to democratize the knowledge and wheels of making complex workplace management tools while enabling people and businesses to create beautiful things on their own by equipping them with a versatile toolbox of building blocks.

License

Distributed under the AGPLv3 License. See LICENSE.md for more information.

Acknowledgements

Special thanks to these amazing projects which help power AppFlowy.IO: