GitJournal: Mobile first Markdown notes synchronized with Git

Too many app developers realize they need some kind of shared state "in the cloud" and end up with a database and a backend server. Many of them would be better off if they had a reliable way to push the state management to a user-controlled space, like a git repo or Dropbox

Sorry about that. A bugfix version will hopefully be soon available.

I'm happy to answer any questions.

The next biggest wish I have is for inclusion and management of binary files. Photos, videos, etc. It'd be nice for them to not be in the git repo, but to still be distributed, addressable, annotatable, and with some kind of cross-platform UI (Linux, Windows, Mobile, Web).

Even better if it's easy to automate workflows to publish to a public personal wiki / blog / website.

https://joplinapp.org/

How does this hold up with storing notes in Git (which usually means syncing to github etc.)? I mean of course you can self-host to keep your notes privately, but does this support encrypted notes? I imagine git history works poorly if notes are encrypted.

    interval_in_seconds=0.5
    previous=""
    while true; 
    do 
        x=$(ls -R -al ./content | md5); 
        if [[ "$x" != "$previous" ]]; then
            previous=$x
            git add *
            git commit -m "Content update"
            # ...
        fi; 
        sleep $interval_in_seconds; 
    done

Unfortunately this app doesn't hold a candle to Markor when it comes to editing and navigating. - Navigating links between files is a pro feature - There is no markdown syntax highlighting while editing - There is no way to favorite or bookmark files to easily navigate to them

As someone who uses GitHub and Markdown as a personal wiki this app doesn't have the features required to be usable for me.

Looks like MGit will continue to be an unfortunate part of my life.

I have always used the builtin wiki from Github/Gitlab to achieve similar note taking. But attachments and links (to and between folders) are a pain to get right ;) So I'd be interested in an app that helps there.

Would love if https://github.com/GitJournal/GitJournal/issues/352 were prioritized, though. Making adding new repos easier would be a big deal for my workflow, as I have multiple customers that all need their own repos, sometimes more than one.

In terms of polish, it's comparable to Craft, but with only the feature-set of Markdown. A few things are missing such as tables and backlinks.

It uses an SQL database for performance reasons, but export to Obsidian is possible within minutes. Indeed, while other file-based alternatives such as NotePlan fail to deal with my 5000+ notes, including images and attachments, Bear is still as smooth as on day one.

Just don't expect new features any time soon. The Bear team has been working on the next version for years, with no end in sight.

I switched to Zettel Notes which has been reliable and fast

The monetisation options are incredibly user-respecting too. Although I don't need the Pro features, I'm on the monthly subscription just to support the project.

Also, you might want to look at this bug as it might be affecting your cash flow: https://github.com/GitJournal/GitJournal/issues/612

https://www.spiceworks.com/it-security/cyber-risk-management...

For my own notes, I've mostly been using Markdown, which doesn't have fenced code blocks, but I've been thinking I might upgrade to a different language like CommonMark or GitLab-Flavored Markdown that does support them. One of the main reasons is the possibility of embedding non-text things in my notes; for example, the other day I was messing around with exact pole-zero cancellation in DSP in https://nbviewer.org/url/canonical.org/~kragen/sw/dev3/pole-..., which involved a lot of TeX equations and data plots of algorithmically generated output. Jupyter notebooks can do those things, but they have a number of extremely serious drawbacks for this sort of thing, such as irreproducibility, aggressively backwards-incompatible file formats, lack of interactivity (despite ipywidgets), unacceptably large "source code" file size, and spurious merge conflicts in Git.

An interesting approach to solving this problem is Mermaid (https://docs.gitlab.com/ee/user/markdown.html#diagrams-and-f...), which lets you include a ```mermaid fenced code block in your Markdown source and replaces it with a rendered image of a boxes-and-arrows diagram in the HTML output. This is sort of backwards-compatible with regular GLFM because things that don't support Mermaid just show the diagram's source code. Mermaid's "flowchart" diagram type is vaguely similar to Graphviz, but I think Graphviz has better syntax and nicer output, so I'd rather use Graphviz for this; Mermaid also has Gantt charts, UML diagrams, sequence diagrams, and entity-relationship diagrams.

GitLab also supports language-tagged fenced code blocks for "math" (KaTeX's subset of LaTeX), "plantuml" (disabled by default, does UML diagrams), and Kroki (also disabled by default, supports Graphviz, Ditaa (warning, domain stolen by SEOs) for flowcharts, Wavedrom for digital timing diagrams, Vega-Lite for data plotting with interactive exploration from JSON, Svgbob for a fairly comprehensive set of ASCII-art line drawings, Burntsushi's Erd for entity-relationship diagrams, bytefield-svg, Pikchr for PIC-like things, several different ASCII-to-UML things, and another dozen or so other similar things).

Pikchr, from the Fossil/SQLite folks, is also designed for embedding in GFML and similar Markdown-derived languages, even without Kroki.

But most of these are just data formats, rather than rich data models or executable code like I'd need for the DSP algorithms I mentioned above. The closest thing I've found for that is Yihui Xie's R Notebooks: https://bookdown.org/yihui/rmarkdown/notebook.html where you can put fenced R code blocks into your Markdown and display the output inline both in the RStudio IDE and in the final rendered document. This still has Jupyter's problem with reproducibility, but solves the problems with massive source files, file-format backwards compatibility, and spurious merge conflicts.

However, R Notebooks require you to write your code in R, which isn't ideal for all purposes, and as far as I know the rendered results don't have a way to do Vega-style or ObservableHQ-style interactive exploration. Also, pretty often I find it easier to sketch a diagram with a pencil than to write code to produce it.

And, for things like analog circuit schematics or 3-D models, while a compact textual representation is achievable, it often isn't the ideal user interface for editing. Mermaid Live, OpenSCAD, and dot -Tx11 filename.gv are three approaches where the text-to-picture flow is one-way, and while they're pretty great, you still spend a fair bit of time hunting through source code for the thing you want to edit and trying to diagnose syntax errors.

So I'd like to have a note-taking system that supports Git and Commonmark, reproducibility so that I don't need to check in giant binary files representing render outputs, plug-in visualizers for different kinds of quasi-textual content, and plug-in editors for editing things like 3-D models, circuit schematics, and 2-D sketches. And I'd like to be able to do things like run a SPICE simulation of a circuit schematic, a FEM simulation of a 3-D model, or a numerical integration of a Modelica model.

Is there anything like that out there? What are the alternative approaches to this kind of algorithmic exploration such as ObservableHQ?

The DSP notebook I mentioned above also includes an input audio sample and several processed versions of it, which you can't hear in the online Jupyter notebook viewer but you can hear if you run it locally. The input audio sample would pretty much have to be an external file, same as a photo, but ideally the processed versions could be recomputed reproducibly rather than stored in Git and copied around all over the net.