Frequently asked questions

Todtler is a distraction-free, terminal-based text editor for writing and editing texts. No toolbars, no panels, just text and a keyboard. It supports the following text formats: ODT (OpenDocument Text), MD (Markdown), Fountain, and TXT (plain text).

Yes. Todtler is free now and will be free forever. Todtler is released under a Pay What You Want model. You can download and use it without paying anything. See Support Todtler if you'd like to contribute.

It depends on what you're writing and where it needs to go next.
ODT is the default, and the right choice for most prose: manuscripts, articles, reports, anything that eventually needs rich formatting like bold, italics, or headings, and that other people might open in LibreOffice, OpenOffice, or Google Docs. It's an open, standardized format, so your writing is never locked into Todtler itself. The tradeoff is that it's a structured document format rather than a flat text file, which makes it less convenient for version control (diffs are noisy) or piping into other command-line tools. Also, (important): Be cautious importing an ODT file created in another application if it contains formatting beyond bold, italics, or page breaks. Things like tables, images, or more elaborate styling won't survive a round trip through Todtler.
Plain text (.txt) is the simplest option, and the best fit when formatting doesn't matter at all: quick notes, drafts you'll reshape later, or anything you want to keep maximally portable and tool-agnostic. The cost is exactly what you'd expect: no bold, no italics, no page breaks, no structure beyond line breaks. What you type is all you get.
Markdown (.md) sits between the two. You get lightweight structure: headings, emphasis, lists, using plain characters, so the file is still just text underneath: clean to diff, easy to version-control with git, and readable even without a renderer. Todtler also lets you fold `#` -prefixed sections (lines starting with a # character followed by a space), so longer Markdown documents stay navigable while you write. It's a strong choice for blog posts, documentation, or notes that need basic structure without the overhead of a full word-processor format. The downside compared to ODT is more limited formatting (no page breaks for example) and it requires a separate renderer or static site generator to turn it into something visually formatted.
Fountain (.fountain) is a specialized plain-text format for screenplays specifically, like scene headings, character cues, dialogue, and transitions are all inferred from simple text conventions rather than manual styling. If you're writing a script, this is almost certainly what you want: it's the standard interchange format for screenwriting software, and like Markdown, it folds nicely by act using `#` section markers in Todtler. Outside of screenwriting, though, it's not a general-purpose format. It won't serve you well for an essay or a novel.
In short: reach for ODT when formatting and compatibility with word processors matter, Markdown when you want structure but plan to keep things in version control or publish to the web, plain text when you want zero overhead and don't need formatting at all, and Fountain specifically when you're writing for the screen.

Todtler doesn't ask for a filename when you open it; it starts with an unnamed document immediately. To end up with a Markdown file, save it with the extension you want:

1. Start Todtler
2. Write your content
3. When ready to save, press ESC S and you'll be prompted for a filename
4. Type your filename with the .md extension, for example notes.md, and confirm

The file is saved as plain text regardless of extension; the .md extension signals to other tools (editors, renderers, Git forges) that the content should be interpreted as Markdown.

Yes. There is one on this site here, as well as in Todtler itself: Press CTRL SPACE to get to the Help screen, then ? to get to the About page, then T for Tutorial.

Linux (AppImage, Flatpak, and standalone glibc/musl binaries), macOS (Apple Silicon and Intel), Raspberry Pi, and Windows. See the Download page for the full list and system requirements.

Nothing, this is expected. Todtler is a terminal application, not a graphical one, so it has to be launched from an actual terminal window rather than by double-clicking the file in a file manager or Finder. Open your terminal first, then run it from there.

Check out the Troubleshooting section at the bottom of the Download page.

Not currently, and it's a deliberate choice rather than a missing feature. Todtler's whole design (keyboard shortcuts, a terminal interface, no touch targets) is built around the idea that staying on the keyboard, without lifting your hands to tap or swipe, is what makes it fast to use. Android doesn't really have that environment: no built-in terminal, no physical keyboard by default, and an interaction model built around touch rather than keystrokes. Bolting on a touch-friendly UI to work around that would mean abandoning the thing that makes Todtler what it is, not just porting it to a new platform.
The one place this could make sense is Termux, a terminal emulator for Android that gives you a real keyboard-driven environment. If there's enough interest, a Termux package is the more realistic path forward rather than a standalone app.

Press Ctrl+Space at any time within Todtler to bring up the full shortcut reference.

Yes. All shortcuts can be remapped by editing ~/.configkeys.conf.

Not quite. Todtler is a hybrid: common actions (bold, save, undo, and so on) use familiar Ctrl-key shortcuts that work all the time, no mode-switching required. A smaller set of less-common actions live behind a single ESC key as a lightweight command layer. It's less expressive than vim's composable verb-plus-motion grammar, but much smaller to learn, and arrow keys still move the cursor normally throughout.

This is a known limitation of how Kitty handles font size changes from within applications running inside it. Todtler changes the font size by emitting terminal escape sequences, but Kitty by default doesn't allow applications to remotely control its font size via escape sequences: it treats font size as a user-level setting rather than something a running program can change. The fix is to enable Kitty's remote control feature, which allows applications running inside it to send control commands back to the terminal itself. Add this to ~/.config/kitty/kitty.conf:
allow_remote_control yes
Then restart Kitty. This allows any application running inside Kitty to send remote control commands, including font size changes.

This happens specifically when running Todtler in the raw Linux console (TERM=linux, the screen you get on tty1–tty6 outside of any graphical session) rather than inside a terminal emulator. The console doesn't use a font renderer the way graphical terminals do. It displays pre-drawn bitmap glyphs with no mechanism to slant or restyle them on the fly, so italics simply has nothing to render with and gets dropped. What looks like "bold" in the console is usually a brighter color rather than a heavier typeface, for the same underlying reason.
The good news: this is purely a display limitation, not a data limitation. When you toggle italics, it's correctly saved in the ODT file regardless of what the console can show you, so the formatting will appear properly the moment the document is opened elsewhere; in LibreOffice, OpenOffice, or any other ODT-aware application. Todtler also shows the active formatting state ("I" for italics, "B" for bold) in the top bar while you're editing, so you always know italics is on even when the console itself can't display it.
Italics will render correctly in any modern terminal emulator running under a graphical session: kitty, foot, WezTerm, and iTerm2 all support it, provided the selected font includes a true italic style (Fira Code, JetBrains Mono, and Cascadia Code all do). This is a limitation of the console environment itself, not of Todtler.

Yes, it does. Todtler is a terminal application, but the quality of that terminal matters more than it might seem.

Todtler relies on true-color support, font rendering, and keyboard handling features that are only available in modern terminal emulators running inside a graphical environment, such as Kitty, Alacritty, or xterm. When launched from a raw TTY (the console you get without any X server or Wayland compositor running), these features are unavailable, and Todtler will either refuse to start or display with a limited appearance and behavior.

What works:

• Any modern terminal emulator inside X11 or Wayland (Kitty, Alacritty, xterm, GNOME Terminal, and so on)
• Kitty inside a minimal compositor such as Cage or Sway on systems with a GPU
• xterm inside a lightweight window manager such as Matchbox. Functional, though appearance may be limited depending on your xterm configuration

What doesn't work, or works poorly:

• A raw Linux TTY (no graphical environment at all). Todtler will not display correctly
• Kitty inside Cage on low-power ARM boards such as the Raspberry Pi Zero. Cage requires GPU acceleration that these boards do not provide
• SSH sessions into a machine without a graphical environment, unless you forward the display or use a terminal emulator on the connecting machine that supports the required features

On Raspberry Pi specifically: a minimal X11 setup with Matchbox and xterm is the most reliable approach on low-power boards. Matchbox is lightweight enough to run on a Pi Zero, and xterm inside it gives Todtler a working environment. Full compositors such as Cage or desktop environments are generally too heavy for a 2W SBC.

Kitty, often recommended for terminal applications with advanced rendering, requires either a native install within a running graphical session, or a compositor with GPU support. It cannot be meaningfully switched to from the CLI on a headless system without first setting up a graphical environment.

It depends on whether you have a graphical environment running.

With X11 (for example, Matchbox on a Raspberry Pi Zero):

xterm reads font settings from ~/.Xresources. Add the following, adjusting the font name and size to taste:

xterm*faceName: DejaVu Sans Mono
xterm*faceSize: 11

Apply the settings before launching xterm:

xrdb -merge ~/.Xresources

To make this permanent, add the xrdb line to your X11 startup script (typically ~/.xinitrc). The font must be installed on your system; on Raspberry Pi OS, a reasonable starting point is:

sudo apt install fonts-dejavu

Increasing the font size is the single most effective change you can make on a small or low-resolution screen.

On a raw TTY (no graphical environment at all):

The Linux console has its own font system, independent of X11. You can change it with:

sudo dpkg-reconfigure console-setup

This lets you select a font and size for the raw console. However, Todtler does not run correctly on a raw TTY regardless of font settings, so while this improves general console readability, it won't affect how Todtler looks.

For anything beyond basic font selection (custom typefaces, ligatures, refined rendering), a terminal emulator with its own font engine is required, such as Kitty or Alacritty. These need a graphical environment with GPU support, which is outside what a Pi Zero can reasonably provide.

On Alpine Linux (TTY):

Alpine users can improve console readability by installing a console-appropriate font package and the kbd toolset, which provides the setfont command:

apk add kbd consolefont-spleen font-terminus

Then apply a font in the current session:

setfont /usr/share/consolefonts/Spleen16x32.psfu.gz

Try different Spleen sizes (Spleen8x16, Spleen12x24, Spleen16x32) depending on your screen resolution. To make the change permanent, add the setfont line to /etc/local.d/console.start, or set consolefont in /etc/conf.d/consolefont and enable the service with rc-update add consolefont boot.

On other distros:

If your distribution provides console font packages and the kbd toolset, installing a console-appropriate font can improve readability significantly. kbd provides the setfont command; good font choices for TTY use are Spleen and Terminus, both designed specifically for console resolutions.

Apply a font in the current session:

setfont /usr/share/consolefonts/Spleen16x32.psfu.gz

The exact path and available sizes vary by distribution and which font packages are installed. Try different sizes depending on your screen resolution. To make the change permanent, consult your distribution's documentation for configuring the console font at boot.

Fill in a feedback note or send me an email and ask. (I use address aliases to keep spam down. If this address ever stops working, check back here for an updated one.)