AI Writing Tools for Zettlr?

hendrik · 2024-12-31T15:30:00+00:00

Hello everyone, I would like to start a discussion regarding AI integration into Zettlr. This has no priority right now, because (a) the community hasn't ye...

hendrik

professed What I definitely don't want is the Clippy-style pop-up that's appearing every other app I use, constantly nagging me to try new AI features or start a chat with the AI assistant.

Excuse me, what? 😃 I mean, I certainly do like clippy, but shoving it into one‘s face is really bad.

I think I now understand your reservations better. And I agree that any AI integration in Zettlr should be exactly as you say: available if users want it, but otherwise invisible. Apologies that I didn’t see that your primary fear was getting it shoved in your face, which I‘d never do, because I try to be nice to people 😃

GeorgEhaase

I've been using Zettlr for a while, and integrating AI tools has been a game-changer for my workflow. For generating text efficiently, I've experimented with different approaches, including combining it with an ai outfit description generator. The key is refining prompts to get the best results without needing excessive edits later.

mononym

One AI application I find extremely useful for writing is Text-to-Speech. Maybe it is counterintuitive, but it helps to switch roles during the process of writing: a step "from authorship to readership" (Something I heard over and over as a useful writing advice). That is by listening to what's writen, kind of in third-person mode. It could be as well that it is maybe a step towards accessibility and makes writing a bit more barrier free. The case of accessibility could also help to find a guideline for integrating AI.

I tried to implement TTS "via the command line". The problem was that it was difficult to pass something from Zettlr to another program. I had to abbandon the idea to read from the clipboard because of Markdown. Then the issue was feeding something to the TTS model which was not formatted in markdown (plain text), even thoug that results in losing some subtilities. Some of it is described here on Discord: https://discord.com/channels/609436111860793355/1168975313942888478

P.S. Thanks so much for opening this forum! I'm done with Discord (:

professed

mononym I agree it'd be useful to have some TTS functionality, as I often find that having a TTS app read my document to me to be helpful for proofreading.

If you're looking for an immediate workaround, you can pass a file from Zettlr to a command line application using a custom export command, which you can set up in Preferences > Import and Export > Custom Export Commands.

As an experiment, in response to your post, I created a custom command, Speak using the command, espeak -f and when I select this export option it indeed uses the espeak command line application to speak the document open in the active tab. There are nicer command line TTS apps, like mimic and piper, as well as ones that connect to APIs of AI TTS engines. So there would seem to be a lot of possibilities.

Obviously, this isn't a perfect workaround, though. There are no playback controls, since the command is launched in the background, and if I want the command-line application to stop speaking, I have to kill the process in a terminal window (e.g., killall espeak), which is less than ideal.

One possibility would be to have the custom export command launch the a terminal window and run the command therein. For example, xterm -e espeak -f or gnome-terminal -- espeak -f. All kludges, but in the absence of a more integrated feature these could be temporary workarounds.

professed

mononym Update: This is pretty slick, actually. The mimic command-line application uses a pretty decent natural-language voice, so I went with gnome-terminal -- mimic -f. This launches the TTS in a terminal window, so I can hit Ctrl-C to terminate it when I'm done with the playback. I'd just add that mimic, like these other command-line TTS apps, has an option to output to an audio file (the -o flag), so it's possible to do an actual export to an audio file and have it play back in your preferred audio player app. You could probably even chain all these commands, so that it launches your favorite MP3/WAV player on export with the TTS output queued up.

professed

mononym Voila! Got it fully working on Linux. Here's what I did:

I used mimic as my TTS command-line application and vlc as my GUI audio player.
I wrote wrote the following bash script, which I titled zet-speak.sh:

#!/bin/bash

mimic -f $1 -o /tmp/tts-output.wav; vlc /tmp/tts-output.wav

I made the bash script executable (chmod +x /path/to/zet-speak.sh).
I created a custom export command in Zettlr by going to Preferences > Import and Export > Custom Export Commands. For the command's display name, I used Speak and for the Command field, I entered /absolute/path/to/zet-speak.sh.

Now, when I want to have a document read aloud, I select Speak from the export menu and it launches VLC with the playback loaded. I can use VLC's playback controls to play, pause, rewind, or adjust the playback speed of the narration.

Because the exported audio is saved to /tmp, it doesn't take up permanent space on my drive. If I do want to save it for later, I can use VLC's save functionality to make a permanent copy.

YMMV on Windows or Mac, but I imagine it's possible to set up a very similar workflow there.

mononym

professed This looks fantastic, thanks !
@hendrik Maybe TTS could be a discussion on its own (in Workflow) apart from the topic of Zettlr & AI ?

I'll try out the snippet with the piper library. Two considerations upfront:

Formatting: what happens with citations, footnotes, comments, etc.
Chunck size: instead of processing the whole file, it is maybe more convenient to be able to process a selection of text, maybe from a right-click context menu ?...

mononym

I added a pandoc step to the script in order to convert the markdown export into a plain text file:

#!/bin/bash

pandoc "$1" --standalone --from markdown --to plain --no-highlight | uv run piper --model ~/apps/Speak/en_GB-cori-high.onnx --output_file /tmp/tts-output.wav; vlc /tmp/tts-output.wav

N.B.: piper was installed with uv: uv tool install --python 3.10 piper-tts

professed

mononym Sweet! Will definitely try this out. Converting the file to remove markdown characters from the text prior to speaking is super smart.

professed

mononym Done! I grabbed a couple custom voices for Piper that I liked from this repo and set up a custom export for each. Works beautifully, thank you.

mononym

professed

Finally, I made a second script which converts and reads an input from selected text. The script is called with a custom shortcut Ctrl+Shift+R after having selected the part to be read.

#!/bin/bash

wl-paste --primary | pandoc --standalone --from markdown --to plain --no-highlight | piper --model ~/apps/Speak/en_GB-cori-high.onnx --output_file /tmp/tts-output.wav; vlc /tmp/tts-output.wav

N.B.: I'm on Wayland and had to install wl-clipboard, the --primary gets the selected text (primary buffer); uv tool did actually install piper to ~/.local/bin/piper.

professed

mononym This looks super cool. I spend most of my time on Xorg because of some software compatibility considerations, so I'll have to look into an Xorg equivalent. Thank you for this, looks super handy.

professed

mononym Used your script for reading input from selected text. Was able to simply substitute xsel for wl-paste.

Also, as another quality of life improvement, I added the --one-instance flag to vlc in all my scripts, so it doesn't spawn a new instance of the player every time I hit the hotkey or do an audio export.

denverhandy

As a writer that left a career of IT, the latter years managing teams, I was forced out voluntarily for not embracing Ai. Not for lack of merit but was disgusted with the deception and the meritocracy it manifested and lack of guardrails. I'm writing a fiction novel and have no intention of using Ai shortcuts in my work. I could not agree more with sensologica in his perception & motivation. Best of luck gentlemen.

sensologica

hendrik

I feel validated by opening up this discussion instead of just dumping AI stuff into the app without thinking; here's a nice video that summarizes my feelings towards the AI slop heading our way. (But please ignore the sponsor segment at the end, the video sponsor is a really, really disturbing company.)

In general, I found his discussion of email summaries in Outlook interesting, because here's why I personally like Apple's stance towards AI. The email summaries in my mailbox are entirely automatic, the computer just produces them, and then even transactional emails of the "someone has shared something with you" type actually benefit from it. That is because the summaries usually mean I don't even have to open the email at all. I generally feel that Apple has a better vision for AI than MS or any other company, and that's what I'm hoping to achieve with any Zettlr AI integration, if that ever comes.

UsmanAkram

hendrik
Great points! I think AI integration into Zettlr could open up powerful workflows, especially for researchers and writers.

Some ideas that come to mind:

Inline rewriting & tone control → perfect for refining drafts quickly.

Summarization tools → very useful for parsing older notes or long research documents.

Abstract generation → even if only a rough draft, it makes starting much easier.

I also agree with you on local-first AI like Ollama. Privacy and data security matter a lot for academics, so this is the right direction.

Another thought: it would be great if Zettlr allowed custom prompt templates (e.g “Summarize into an academic abstract” vs. “Simplify for a blog”). That way, users can shape AI to their specific workflows.

By the way, if you’re interested in automation + AI workflow solutions, check this out: Zaytrics

Excited to see how this evolves!

ama

I've just recently learned about Zettlr and I'm starting to quite like. I was looking for answers to a different question and have stumbled upon this thread. I've been using Logseq for some time already, which I also like a lot, but I'm getting the feeling that I might want to move to Zettlr or perhaps use both.

Anyways, I'm telling you guys all this, because Logseq integrates AI at any point you want, whether a daily log, a dedicated page, etc., very easily and it works quite nicely. Perhaps their implementation could be of help or inspiration to add that functionality to Zettlr. As I understand it, they have implemented as a plug-in which adds functionality in a modular fashion.

As I said, I'm very new to Zettlr, but I've thought that this info could help somehow...

cmoney

This is a good idea and actually something I have already implemented. I put in an AI module so that I can click a button and a pane pops up with a dropdown menu and several options. I have improve/rewrite this document, create a project README, which includes exploring the root of the projject directory, mapping out the entire folder/file structure, incorporating a comprehensive diagram of the project structure into the README and then I wrote a template that the model is to follow to write this comprehensive README, which includes installation steps, a thorough explanation of the core features, presented in a novel and marketable light, and so forth.

I have also added the ability to tell Zettlr the path to my preferred terminal emulator, and then the ability to pipe custom commands into that emulator, save those commands, and access them from a toolbar button. This allows things like editing a .py file, clicking my "Run" button, which exposes a list of my custom commands, and choosing the one that is associated with the current project's venv, which then automatically runs the current project directory's entry point, via the venv, and piped directly into my terminal.

Those are just a couple of the ai enhancements I personally have made to Zettlr and they have saved me tens of hours in my workflow.

cmoney

By the way, I was so fed up w/ there not being a way so SEE visual elements/documents in my IDE--which makes zero sense; it is an absolute no-brainier to include the ability to render markdown, html + CSS, LaTex w/ elements, svg, etc., in the IDE, that I actually wrote a bare-bones Zettlr-esque app for personal use before I discovered this phenomenal app. This is such an intuitive, no-brainer, value-add times a million kind of app--and the fact that it's open source--that I can't believe I just discovered it recently. I honestly absolutely love it. Very well conceived and engineered, intuitive, very strong coding and design choices--overall wonderful job. Keep up the phenomenal work!

cmoney

Sorry for the back-to-back-to-back posts -- I swear this is the last one. Below is the spec I used to implement the AI module that supplants the very outdated "Readability" toggle. The logic behind those readability formulas is completely backwards, in my opinion, and most definitely outdated.

Below is a clean, high-level sketch of the actual readability module that would make sense in 2025 — and what legacy tools completely fail to approximate.

SMART READABILITY MODULE (2025 Spec — LLM-Integrated, Context-Aware)

A replacement for Dale-Chall / Fog / Coleman-Liau / ARI.
This measures quality, precision, and genre-fit, not “grade level."

1. Architecture Overview

Core idea:
A small local model (Phi-4, Qwen2-1.5B, DeepSeek-R1-Distill, etc.) analyzes the open document and returns a structured JSON describing its readability features — but genre-aware, audience-aware, purpose-aware.

Inputs:

full text buffer
optional metadata (genre dropdown)
target audience (expert, general, public-facing)
tone/precision preferences
model backend (Ollama server, custom API endpoint, etc.)

Outputs:

sentence-level annotations
paragraph-level summaries
issue flags
clarity/precision maps
structural flow map
scoring by purpose, not by grade level

Everything is returned as structured ranges (start/end char indices) so the editor can color-code regions.

2. UI Structure

A single toolbar button opens an analysis panel.

Left pane:

Genre selector (legal, academic, README, technical, conversational, scientific, grant writing)
Audience selector (expert, semi-expert, general, broad public)
Model settings (base URL, API key, model ID)
Toggle: “Highlight clarity,” “Highlight precision issues,” “Highlight redundancy,” etc.

Right pane:

Dynamic heat-map overlay on the document:

subtle color gradients
clickable flags
in-line explanations

Not the neon green/red nonsense — more like soft overlaid cues.

3. Analysis Dimensions (the useful ones)

A. Clarity Analysis

flags sentences where clause stacking exceeds expected limits for the selected genre
detects buried subjects/verbs
highlights convolution that isn’t contributing real precision
identifies sentences that “meander,” even if syntactically valid

Example flags:

“Clause stacking: 4 levels”
“Delayed main verb”
“Ambiguous referent; two possible antecedents”

B. Precision Analysis

Essential for legal/technical use.

identifies vague terms
flags softening verbs (“seems,” “may,” “might”)
flags nominalization bloat
flags hidden ambiguity

C. Redundancy & Repetition

checks for repeated phrases
checks for duplicated content across sections
checks for argument cycles in briefs

D. Consistency Mapping

technical term consistency
defined term mismatches (“the Agreement” vs “this Agreement” vs “the contract”)
capitalization consistency
tense drift

E. Structural Flow

A paragraph-level cohesion check:

does each paragraph deliver one logical unit?
do transitions match the argument or topic?
are you introducing concepts twice?
is the order coherent given the content type?

For README docs:

checks if steps are sequential
checks if prerequisites appear before usage
checks if terminology is consistent

F. Genre Norm Matching

This is where legacy formulas are completely useless.

The module compares the document to genre expectations:

Legal brief → dense, layered, highly precise, long sentences expected
README → clarity prioritized, direct imperatives expected
Academic paper → moderate complexity, cohesive argument structure
Public summary → low jargon, short sentences, linear logic

The tool scores sentences against genre norms, not kindergarten-level heuristics.

4. Color Overlays (purpose-driven)

Instead of red=bad / green=good:

Blue: unnecessary complexity (genre mismatch)
Amber: redundant clause or repeated info
Purple: precision problem
Grey hatch: low-value filler
Silver outline: logic jump or missing connective tissue

Each highlight is tied to a reason field in the JSON returned by the LLM.

5. Backends (Ollama-friendly)

The module exposes:

Base URL field
Model ID field
API key field
Temperature / max tokens / top_p

For local use:

http://localhost:11434
model: phi4, qwen2.5-3b, etc.

For BYOK:

accept any OpenAI-compatible API

This avoids forcing cloud usage and keeps everything local.

6. JSON Specification (returned by the model)

Something like:

{
  "sentences": [
    {
      "start": 120,
      "end": 184,
      "issues": [
        {"type": "precision", "detail": "ambiguous referent"},
        {"type": "complexity", "detail": "clause stacking: 3 levels"}
      ]
    },
    {
      "start": 185,
      "end": 245,
      "issues": [
        {"type": "redundancy", "detail": "repeats concept from paragraph 2"}
      ]
    }
  ],
  "flow": {
    "paragraphs": [
      {"index": 0, "cohesion": "medium", "note": "topic introduced twice"},
      {"index": 1, "cohesion": "strong"}
    ]
  }
}

The editor only needs to paint regions.
The intelligence lives in the model.

7. Why this solves the problem

Because this system:

respects expert domains
understands legal necessity
handles README clarity differently than legal precision
detects real writing issues (ambiguity, redundancy, drift)
doesn’t penalize complexity that is required
moves beyond 1940s readability formulas

This is the actual evolution of the idea.

The coloring becomes meaningful, not infantilizing.

The module becomes a genuine writing tool instead of “count the syllables and panic.”

Done.

« Previous Page