# jrnl: a command-line journal for capturing thoughts without friction

> A Python CLI tool for writing and managing a personal journal. Supports natural language timestamps, AES encryption, plain text storage, and external editor integration. Runs on Linux, macOS, and Windows; requires Python 3.11+.

**jrnl-org/jrnl** — Collect your thoughts and notes without leaving the command line.

- Repository: https://github.com/jrnl-org/jrnl
- Website: https://jrnl.sh
- Stars: 7,328 · Forks: 566
- Language: Python
- License: GPL-3.0
- Published: 2026-09-22 · Updated: 2026-09-22 · Language: en
- Canonical page: https://hysenlabs.com/projects/jrnl-org-jrnl

## The problem: journaling tools demand context switching

Most journaling applications are web apps or desktop software that require you to leave your editor or terminal, open a new window, and use an unfamiliar interface. By the time you are there, the momentum of thought is lost. jrnl solves this by living in your terminal as a command-line application. You stay in your working environment, invoke jrnl, type your entry, and continue. No context switching, no friction, no web page to load. The application stores entries as human-readable plain text, so you can also edit them directly in any text editor if you choose.

## Natural language timestamps and entry parsing

When you create an entry, jrnl interprets the timestamp automatically. For example, `jrnl yesterday: Called in sick.` parses `yesterday:` as the timestamp and treats the rest as the entry content. The first sentence (ending with `.`, `?`, or `!`) becomes the title, and the rest becomes the body. If you type just `jrnl` with no arguments, the application prompts you to compose an entry interactively. The README mentions that you can also configure jrnl to use your external editor (like Vim or Emacs) for composition, making it feel like a natural extension of your command-line workflow.

## Plain text storage and optional encryption

All journal entries are stored as plain text, so you can read, edit, and backup them manually without special tools. The format is human-readable: `[2012-03-29 09:00] Called in sick.` followed by the entry body. This transparency is valuable because your journal will outlast any proprietary tool; if jrnl is abandoned, your data is still accessible. jrnl also supports AES encryption via the cryptography library, so you can protect sensitive entries with a password. The README does not detail the encryption workflow, but the pyproject.toml lists cryptography as a dependency, and the application can be configured to encrypt the journal file.

## Installing jrnl and writing your first entry

jrnl requires Python 3.11 or later. Install it via pip:

```bash
pip install jrnl
```

Or on macOS using Homebrew. Once installed, create your first entry by typing:

```bash
jrnl yesterday: Called in sick. Used the time to clean the house and write my book.
```

The `yesterday:` part is interpreted as the timestamp. Everything until the first sentence-ending punctuation (`.`, `?`, or `!`) becomes the title. The rest becomes the body. If you run `jrnl` with no arguments, you enter interactive mode where you are prompted to compose your entry manually.

## Searching and viewing entries

The README states you can search and view journal entries, though it does not detail the syntax. The project has been in operation since 2012, indicating a mature feature set for querying and filtering. The documentation at jrnl.sh covers the full list of commands for searching, viewing, exporting, and managing entries. The pyproject.toml shows that jrnl depends on parsedatetime for natural language date parsing, so searching by relative dates (e.g., "entries from last week") is likely supported.

## External editor support and rich terminal output

The README mentions you can configure jrnl to use your external editor for composition. This means you can write entries in Vim, Emacs, or any text editor you prefer, and jrnl will import the result. The pyproject.toml lists rich as a dependency, which is a library for rendering formatted text in the terminal. This suggests jrnl uses rich to display entries with colors, styling, and formatting, making the terminal output more readable than plain text.

## Maintained by three core contributors with Open Collective funding

jrnl is maintained by Jonathan Wren, Micah Ellison, and Aaron Lichtman, with support from numerous code contributors. The latest release is v4.6, published 2026-08-07, with a beta version v4.6-beta from 2026-08-06. The last push to the repository was 2026-09-27, less than two days ago. The project is funded via Open Collective, allowing users to contribute financially. The README mentions the project has a Gitter chat for community discussion and a GitHub issue tracker.

## Terminal-only, local-only, plain text entries

jrnl offers no graphical user interface or web interface, only a terminal command-line application. There is no cloud sync or multi-device support; your journal is a local file on your machine. The README does not mention rich text formatting, so entries are plain text only. jrnl also does not provide templates or structured entry formats; it is designed for free-form writing. The GPL-3.0 license means you can modify and redistribute the source, but any modifications you distribute must also be under the same license. The application requires Python 3.11+, so it will not run on systems with older Python versions.

## Conclusion

Adopt jrnl if you work primarily in the terminal and want a lightweight, private journaling tool that stores everything as editable plain text. Skip it if you need rich text formatting, cloud sync, or a graphical interface. Start by installing via `pip install jrnl` and typing `jrnl yesterday: Your first entry here.` to see how timestamps and entry parsing work.

## FAQ

### How do I start writing in jrnl?

Install with `pip install jrnl`, then type `jrnl yesterday: Your entry here.` The part after the colon is your journal entry. You can also type `jrnl` with no arguments to be prompted for a new entry.

### Is my journal file encrypted?

jrnl stores entries as plain text by default, which is human-readable. You can optionally enable AES encryption to password-protect your journal file. The encryption is handled by the cryptography library.

### Can I edit my entries with a text editor?

Yes. Since jrnl stores entries as plain text, you can edit the journal file directly in any text editor. You can also configure jrnl to use your preferred external editor (Vim, Emacs, etc.) when composing new entries.

## Sources

- [jrnl-org/jrnl on GitHub](https://github.com/jrnl-org/jrnl)
- [License: GPL-3.0](https://github.com/jrnl-org/jrnl/blob/main/LICENSE)
- [Project website](https://jrnl.sh)
- [README](https://github.com/jrnl-org/jrnl/blob/main/README.md)
- [Releases](https://github.com/jrnl-org/jrnl/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/jrnl-org-jrnl