Finance:
    Rotki:
        https://rotki.com/#download
        
    OpenBBTerminal:
        https://openbb.co/
        
    MoneyManagerEx or Firefly III
        https://moneymanagerex.org/
        https://www.firefly-iii.org/

Text Processing:
    LaTeX:

        Linux, TeX Live:
            https://tug.org/texlive/quickinstall.html
            # installation via tug preferable over outdated APT packages on Debian distros


        Windows, MiKTeX:
        https://miktex.org/

    LibreOffice:
        https://www.libreoffice.org/
        
Learning Software:
    Anki
        https://apps.ankiweb.net/

    Plugins:
        Image occlusion enhanced, https://github.com/glutanimate/image-occlusion-enhanced
        Anki Connect, https://github.com/FooSoft/anki-connect
        Obsidian to Anki, https://github.com/Pseudonium/Obsidian_to_Anki

    Memcode
        https://www.memcode.com/

Information Organization:
    Obsidian
        https://obsidian.md/
        
            Plugins:
                Excalidraw, https://www.zsolt.blog/2021/03/showcasing-excalidraw.html
                Obsidian to Anki, https://github.com/Pseudonium/Obsidian_to_Anki
                Obsidian Git, https://github.com/denolehov/obsidian-git
        
            Alernatives:
            appflowy
                https://www.appflowy.io/
            
            joplin
                https://joplinapp.org/
            
            LogSeq
                https://github.com/logseq/logseq
                
            GitJournal
                https://github.com/GitJournal/GitJournal
        
    Zotero
        https://www.zotero.org/
        
        Plugins:
            BETTER BIBTEX FOR ZOTERO
                https://retorque.re/zotero-better-bibtex/
        
        Settings:		
            Citation Key	
                auth.lower + year + veryshorttitle.lower

            File name format for PDFs to year-author-title
                extensions.zotero.attachmentRenameFormatString
                {%y - }{%c - }{%t{50}}
    
        Alternative:
            JabRef
                https://www.jabref.org/
    
Visualization Software:
    diagrams.net (previously draw.io)
    https://www.diagrams.net/

    Markmap
        https://github.com/gera2ld/markmap
    
    Freeplane
        https://www.freeplane.org/wiki/index.php/Home
        
    Xournal++
        https://github.com/xournalpp/xournalpp

Creative Software:
    Krita:
        https://krita.org/en/
        
    Pinta:
        https://www.pinta-project.com/

    Excalidraw:
        https://excalidraw.com/
        
    Inkscape:
        https://inkscape.org/de/

    Kroki:
        https://kroki.io/

    Kdenlive:
        https://kdenlive.org/en/

    LMMS:
        https://lmms.io/

    MuseScore:
        https://musescore.org/

    Blender:
        https://www.blender.org/
        # blender uses a 3D polygon model and is targeted at animation, art and game design
        # therfore a circle is not a circle but a set of polygons
        # therefore it serves as alternative to Maya and 3ds Max
        # however it has plugins to do parametric modelling similar to FreeCAD
        # and it has a python API which can be used similar to OpenSCAD
    
        FreeCAD:
            https://www.freecad.org/
            # FreeCAD uses a 3D parametric model and is targeted at mechanical design
            # therefore a circle is always a circle
            # therfore it serves as alternative to Siemens Solid Edge and Fusion 360
            # however it's a bit buggy and blender has plugins that allow doing precision
    
        LibreCAD:
            https://librecad.org/
            # LibreCAD uses a 2D parametric model
            # because it's 2D it is fast, small and simple
            
        OpenSCAD:
            https://openscad.org/
            # OpenSCAD uses a parametric model and is targeted at mechanical design
            # OpenSCAD is not an interactive GUI-driven software but rather a compiler
            # a script defines a model
            
    Scribus:
        https://www.scribus.net/
    
    OBS Studio
        https://obsproject.com/
        
    Audacity
        https://www.audacityteam.org/
        
Programming Software:
    Python 3:
        https://www.python.org/

    Java JDK:
        https://www.oracle.com/technetwork/java/javase/downloads/index.html

    Maven:
        https://maven.apache.org/install.html

    Nodejs:
        https://nodejs.org/en/

    GCC:
        https://gcc.gnu.org/

    GDB:
        https://www.gnu.org/software/gdb/

    Valgrind:
        http://valgrind.org/

    Git:
        https://git-scm.com/

    Visual Studio Code:
        https://code.visualstudio.com/download
        
    neovim:
        https://neovim.io/
    
    Haskell:
        https://www.haskell.org
        
    Rust:
        https://www.rust-lang.org

    Julia:
        https://julialang.org/

Acadamic Software:
    Engauge digitizer:
        https://github.com/markummitchell/engauge-digitizer

    WebPlotDigitizer:
        https://github.com/ankitrohatgi/WebPlotDigitizer

    GPower:
        http://www.gpower.hhu.de/

    Language Proof and Logic (Frege (17.12, December 2017) which consists of: Boole 4.2.0, Fitch 3.7.0, Submit 3.1.0, and Tarski's World 7.2.4)
        New Site:
            https://proto.gradegrinder.net/Products/lpl-index.html
        Old Site:
            https://ggweb.gradegrinder.net/lpl/features

    ACT-R:
        http://act-r.psy.cmu.edu/software/

    Nengo:
        https://www.nengo.ai/

    NLTK:
        https://www.nltk.org/

    R Project:
        https://www.r-project.org/

    R Studio:
        https://www.rstudio.com/
    
    Radian. A better R console:
        https://github.com/randy3k/radian 

    JASP:
        https://jasp-stats.org/

    WolframAlpha:
        https://www.wolframalpha.com/

    GeoGebra:
        https://www.geogebra.org/

    Protégé:
        New:
        https://protege.stanford.edu/
        Old:
        https://protege.stanford.edu/download/protege/4.3/installanywhere/Web_Installers/
    
    Octave:
        https://www.gnu.org/software/octave/download.html
        
    KiCad:
        https://www.kicad.org/

Security Software:
    Bitwarden:
        https://bitwarden.com/

Zettelkasten Apps

Overview

• Architecture after Luhmann's Zettelkasten.
  • The Zettelkasten method in English.
  • The Zettelkasten method in German.
  • Another term for the Zettelkasten is the Second Brain.
• Current implementations.
  • A Java implementation of the Zettelkasten with an old-school user interface.
  • Neuron, a Haskell implementation. Very cool project, also uses Nix and Matrix. Emanote, a currently, seemingly, less popular successor to Neuron by the same author.
  • Obsidian is a proprietary, cross-platform, markdown-based note taking tool. With a focus on cross-references and building a knowledge graph it's similar to the Zettelkasten. Other similar proprietary apps are Notion (client is open source), Roam Research, RemNote with support for flash cards.
  • Logseq is an open source Obsidian clone. Markdown based format. Supports mobile and dekstop. Flash-cards are a baked in feature.
  • AppFlowy.IO is a Notion clone. The tech stack is in Rust and Dart/Flutter. The project is in early development as of November 2021 but gaining popularity rapidly with over 8k stars on GitHub. The project is open source and AGPL-3 licensed. This could be the most promising project in the future. Due to Flutter multi platform comes per default.
  • Foam is a Roam based VSCode extension.
  • Don't allow linking to subsections of a Zettel. A Zettel should be atomic and KISS.
• Editor.

  • The system should be usable even when limited to only sending text messages to your Zettelkasten.

  • The system should feel as plastic and haptic as possible.

  • VSCode is a dekstop and web supported text-editor with extensions.

  • Zettlr is a desktop-only TypeScript based Zettelkasten enabled Markdown note-taking app.

  • Joplin is a web-mobile-desktop TypeScript-based note taking app with paid syncing options. Standard Notes seems similar but a bit worse. Joplin has a plugin repository with some Zettelkasten and flash card related functions.

    • A graph visualization of the connectome of notes is given here.
    • Backlinks, listing all references to a current note, is supported here. The functionality is explained here.
    • Exporting notes with Q/A pairs to Anki for flash card functionality.
    • Automatically recognizing possible references in a note to other notes and creating links, here.
    • Quickly linking notes by their title, on GitHub, discussion here. This plugin does something similar. And this plugin also.
    • Multiple note tabs.

  • FSNotes is a iOS and Mac only note taking app in Swift.

  • 3D representation and VR with the Zettelkasten.

• UI.
  • The UI is a key component.
  • Touch optimized.
  • Keyboard optimized.
  • Expand on horizontal stacking for multiple Zettel as in Obsidian.
    • Freedom of i3wm.
  • Natural flow between one viewing mode into the other.
• Export and import to and from many formats.
  • Import from a collection of .md files such as maintained with Obsidian.
  • Import from a loose collection of data .odt, .doc, docx. Use NLP and clustering for creating Zettel.
  • Import from services such as EverNote, OneNote.
  • Export entire Zettelkasten.
    • To database dump.
    • To collection of markdown files.
    • To a single PDF or to a collection of PDFs by filters.
    • To EPUB.
    • To JSON.
• Visualization: Support for mind map or tree generation.
  • Visualize markdown as a tree. Implemented in Typescript.
    • Available as extension in VSCode.
  • Mind map software in Javascript.
  • Alternative mind map software in Javascript.
  • Diagrams.net formerly Draw.io is a general purpose diagramming software.
  • Visualization should allow (1) eagle-view of all nodes (2) filtering for incoming nodes of some node (3) filtering for outgoing nodes of some node.
  • 3D-printable topological map of the Zettelkasten.
• Learning: Support for flash card generation.
  • Memcode is a flashcard webapp written in Javascript.
  • Anki consists of an open source desktop app, Android app, and a proprietary web app and iOS app.
  • AI-feature to convert a Zettel to a closure flashcard or to formulate a question that is answered by the Zettel. Separate label for AI-generated questions/closures. Allow regeneration and user-selection of best generation.
  • Active recall learning with spaced repetition on a subset of Zettel.
• Blogging: Support for publishing a collection of Zettel to the web.
  • See this example generated from notes about a TV-show using the Neuron app.
  • See this example generated from Obsidian publish.
• Search and filtering.
  • Test multiple search algorithms.
  • Strive for something like Google's MUM: Multimodal search with for example auto-generated labels for images in a Zettel.
  • Chronological view of the Zettel creation history.
  • Visualization of meta-information. For example zettel creation frequency.
• Labels/Tags as feature-controllers and as filters for a Zettel.
  • Example: filtering by a diary-label, university-label or a specific course-label.
  • Example: Generating a Flashcard from a Zettel should only be possible when a flashcard-label is present and a question or closure can be located on the Zettel.
• Support for news.
  • Receive updates on topics inside your Zettelkasten from the Web.
  • Configure sources: Google, Google Scholar, Reddit, NY Times, The Economist, Twitter, Nature, Science, The Lancet.
  • Receive news from (1) manually selected and filtered Zettel (2) most recent Zettel (3) most connected Zettel (4) most referencing Zettel (5) most referenced Zettel.
  • Automatic Zettel creation from a news article using AI an generated modifiable summary. Includes automatic reference to article.
• Multi-modal data support: vector-graphics-canvas, text, 2D images, 3D images, latex, code, audio, 2D video, 3D videos.
  • In the long run, code execution for many programming languages could be possible with WebAssembly. In the short term remote code execution could be offered as a service.
  • To integrate sketching see Excalidraw.
  • AI tools to generate multi-modal. For example automatic transcription of voice recordings.
  • Integrate arbitrary external documents.
    • Example: Allow loading a paper's full PDF into the database. Clicking on a reference then opens the PDF.
• Multi-note and multi-user support for synchronous and asynchronous editing.
  • View, edit and delete multiple local Zettel at the same time.
  • Share Zettel with other users. Push and pull synchronization similar to git with remote Zettelkasten.
  • Mount remote Zettelkasten giving the option to pull. Or clone making an independent, non-updating copy. Automatic cache before pulling with option to sever ties to remote Zettelkasten on a given set of nodes.
• Uses a database to grow a lifetime.
  • SQlite is a database but not overkill. Concurrency relies on file-locking. This is acceptable for a small number of concurrent users.
• Prototype/MVP in HTML, CSS, Javascript targeting web.
  • Could be packaged with Electron for desktop apps.
  • Could be packaged with Ionic's Capacitor for mobile.
• VR.
  • There is a rich ecosystem of note taking, learning, productivity management, knowledge management and collaboration apps.
  • VR will grow a lot in the future.
  • Remove tradeoffs between the physical and the digital Zettelkasten.
  • Visualizations and knowledge in the 3D dimension are more comprehensive.
  • Needs a game engine.
    • Godot on GitHub. An article about why it isn't Entity Component System (ECS) based.
    • Unity seems the most fully featured and advanced game engine.
  • WebGL supports XR via the WebXR Device API
  • Tradeoffs between 3D, 2D and speech/audio interactions and views, paper, doi.
• An advanced app could be in Dart/Flutter targeting mobile, desktop, web.
• Cross-platform and synchronized.
  • Centralized synching as a service.
  • Centralized synchronization via external Clouds such as Nextcloud, Dropbox, Google Drive, iCloud, OneDrive.
  • Local syncing via Syncthing.
• Reconstruction.
  • You only learnt about the Zettelkasten after finishing university. How to add everything?
  • You text people great ideas. But this was all before the Zettelkasten. How to aggregate it all?
• Grammatical note: In German's Nominative case it's "1 Zettel, 2 Zettel" but English doesn't have cases and "1 Zettel, 2 Zettels" sounds kind of natural in English.
• AI-it-up.
  • Sentiment analysis.
  • NLP.
  • Text completion aid.
  • Text regularization by recognizing patters. For example aligning year_month and month_year occurrences into one.
• Questions
  • Labels and folders?
    • Are they really good or are they a bad idea?
    • There is a natural tendency to want to use folders.
    • There is a natural tendency to want to use labels.
    • But why wouldn't that just be represented by nodes?
      • Example: A label for your linear-algebra course?
      • The advantage: allows focusing on a specific set of nodes that can otherwise not as easily be selected. Do we want to link each node related to the course to the main topic? No we don't. We don't want to have to link matrix-multiplication to linear algebra. It's already connected to matrices which in turn are connected to linear algebra. Or maybe there is something here about path length enabled filtering that is superior to labels, because technically it would be more atomic and minimalistic to avoid labels/tags. Or if tags are implemented, then that they are just syntactic sugar around actually just a link to an existing Zettel.
  • Links to sections within a Zettel, for example referring to second subheading?
    • Con: this encourages large Zettels
    • A Zettel should be 1-3 questions and one coherent answer
    • Pro: Obsidian supports this and it doesn't feel too bad.
    • Discussion: Sub-linking could encourage writing reports and essays inside the Zettelkasten. Of course, it's possible to write big documents inside the Zettelkasten without sub-linkink. However such documents should be an aggregation and therefore reference a lot instead of being sources and therefore being referenced a lot.
• Decentralized governance and infrastructure.
  • Use Filecoin (FIL) and IPFS for storage.
  • Use Internet Computer (ICP) for compute.
  • Use The Graph (GRT) for indexing.
• Multi-view read and write
  • For example write flash card -> it's inside a linear text -> it's inside a Zettel
  • Write a Zettel -> it's a flash card -> it's inside a linear text or summary
  • Write a summary or linear text -> it's converted to atomic Zettels -> it's converted to flash cards
• What file saving model?
  • One file dump?
  • Files per zettel?
  • folder per zettel?
• How to make links?
  • Numbers
  • ids
  • names
  • how to reference other nodes and how to be referenced
• Feature: an ordered list by how incomplete notes seem
• An example of powerful Obsidian usage is given by Ryan Murphy, a PhD in management. Ryan uses Obsidian on an iPad. "How to Design Your Obsidian app as an Integrated Thinking Environment | LYT House Episode 5". More on Fulcra, Ryan's project website. His use case is related to cybernetics and control theory, see Stafford Beer, see "Cybernetic Revolutionaries" by Eden Medina.

Conclusion

When combining Obsidian and Ankia via the Obsidian to Anki plugin half of the problem is solved. Furthermore, an excalidraw plugin for Obsidian allows quite convenient drawing. Lastly, a chatbot plugin for obsidian allows the use of AI completions; this can be particularly useful for generating question-answer pairs from a document. Some improvements here could be achieved by extending existing plugins with pre-made prompts.

The only thing that would now warrant the development of a new note taking app, with so many options in the eco-system would be something that fully integrates AI, continuously reading all notes, making suggestions, preparing lessons, etc.