简体中文
EnglishWebsite review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is jrnl?
jrnl is a command-line journaling tool that lets you write dated entries by typing a sentence into your terminal instead of opening a separate app. Its defining feature is a natural-language interface: you write something like "Went for a run today. Feeling good." and jrnl files it as a timestamped entry, so you don't have to memorize formatting commands for routine writing.
What it does well
- Plain-text storage. Entries live in readable text files rather than a proprietary database, so you can open, search, back up, or edit them with ordinary tools.
- Multiple journals. You can keep separate journals for work, personal life, travel, or a specific project, and switch between them.
- Encryption. Journals can be protected with AES encryption, which matters if you keep sensitive material on a shared or synced machine.
- Sync-friendly. Because entries are just files, you can place them in a synced folder (Dropbox, a Git repository, or similar) to reach them from more than one computer.
- Free and open source. The project is community-maintained.
Who it suits
It fits people who already spend the day in a terminal — developers, sysadmins, researchers — and anyone who wants to capture a thought without breaking focus or switching windows. It also suits writers who care about longevity: plain text is likely to remain readable long after a niche note-taking app shuts down.
It is a poorer fit if you want rich formatting, images, handwriting, mobile-first capture, or a graphical timeline. Command-line entry is fast for text and awkward for anything else.
A practical way to start
Pick one narrow use first — a work log you append to once a day — and keep the journal file in a folder you already back up or sync. If the habit sticks, add a second journal for personal notes. If typing a command feels like friction after a week, that is a clear signal a graphical app will serve you better.
For a different balance of convenience and portability, Obsidian stores notes as local Markdown files with a graphical editor, and Simplenote offers quick plain-text capture with syncing across devices.
How do I install and set up jrnl for the first time?
jrnl is installed with a package manager, then configured by creating a journal file and adding an entry. The official documentation at jrnl is the authoritative source for current commands, since installation methods and defaults change between releases.
Typical first-time path
- Install it. The common routes are
pipx install jrnl(orpip install jrnl) for a Python-based install, or a system package manager such as Homebrew on macOS. Pick one method and stick with it, so upgrades stay predictable. - Create your first journal. Running
jrnlfor the first time with no journal configured prompts you to set one up. You choose a name and a file location; jrnl writes a small config file (by default under~/.config/jrnl/) pointing at a plain-text journal file. - Write an entry.
jrnl today: Went for a run. Felt good.creates a dated entry. The natural-language tags (today:,yesterday:, or a date) are what make jrnl feel like writing rather than filling in a form. - Read it back.
jrnl -n 5shows the last five entries;jrnl -from "last week"filters by date. Search works with plain words, e.g.jrnl run. - Add more journals if you want. You can define several journals — work, personal, travel — and target one with
jrnl work: ...or by passing-journal work.
Decisions worth making early
| Choice | Why it matters |
|---|---|
| Plain text vs. encrypted | jrnl stores entries in plain-text files by default; AES encryption is available if the content is sensitive. Encryption means losing the password means losing the journal. |
| Local file vs. synced folder | Putting the journal file in Dropbox, Syncthing or a Git repo gives you access from multiple machines, but sync conflicts can corrupt a file if two devices write at once. |
| One journal vs. several | A single journal is simpler to search; separate journals keep work and personal notes from mixing in results. |
A practical scenario: a developer keeps a work journal in a synced folder for standup notes and a local encrypted personal journal, then searches each separately. That split costs nothing and avoids leaking private entries into a work-wide search.
Your useful next step is to run jrnl --help after setup — it lists the date filters and journal flags you will actually use day to day — and to check the jrnl documentation for the current install command for your platform before copying anything from an older tutorial.
How can I encrypt my journal entries with jrnl?
Encryption in jrnl is set per journal, not per entry. You point jrnl at an encryption method for a whole journal file, and from then on everything written to that journal is stored encrypted. There is no per-entry toggle, so the practical decision is which journal you want protected.
How it works in practice
jrnl supports AES encryption and can also hand off to a GPG key. You choose the method when you create the journal, or by editing the journal's configuration. Once a journal is encrypted, jrnl asks for your password (or uses your GPG agent) when reading or writing that journal.
A typical setup looks like this:
- Open your jrnl config file (usually
~/.config/jrnl/jrnl.yaml). - Find the journal you want to protect, or add a new one.
- Add an
encryptkey to that journal with the method you want, for exampleencrypt: passwordfor AES with a password you type, orencrypt: gpgto use a GPG key. - Save the file and run any jrnl command that touches that journal. jrnl will prompt for the password or GPG passphrase and rewrite the file in encrypted form.
Choosing between password and GPG
| Method | Best for | Trade-off |
|---|---|---|
| Password (AES) | A single person on one or a few machines | You must remember the password; lose it and the journal is unreadable |
| GPG | People already using GPG, or teams with shared keys | More setup; depends on your GPG keyring and agent |
The password route is the simplest. The GPG route makes sense if you already sign commits or encrypt email, because the key management is already in place.
A concrete scenario
Suppose you keep two journals: work for meeting notes and personal for private reflections. You would leave work unencrypted so you can grep it quickly, and set encrypt: password only on personal. When you run jrnl personal: today I..., jrnl prompts once and writes the entry encrypted. Reading it back with jrnl personal -n 5 prompts again.
What to watch out for
- Encryption applies to the whole journal file, so you cannot mix plain and encrypted entries in one journal.
- If you sync the file with Dropbox or a similar service, the synced copy is encrypted, but the password is not stored there. Keep it somewhere you can recover.
- Back up the password or GPG key separately. Losing it means losing the journal, as the project itself notes.
- If you already have a plain-text journal, test the encryption step on a copy first, since the file is rewritten.
A useful next step is to read the encryption section of the official documentation at jrnl and check the exact encrypt values your installed version expects, then try it on a throwaway journal before converting one you care about.
How do I sync my jrnl journals across multiple devices?
jrnl itself doesn't run a sync service. Its journals are ordinary plain-text files, so syncing means putting those files in a folder that another tool already keeps in sync across your machines. The page evidence explicitly suggests syncing your journal files with tools like Dropbox, and its "Accessible anywhere" point frames this as the intended path.
The basic setup
- Find your journal file. jrnl stores journals as plain-text files, so locate the file (or files) behind your journal name — jrnl supports multiple journals for different parts of your life, so you may have several.
- Move it into a synced folder, or point jrnl at a journal that already lives there. jrnl's documentation covers configuration for choosing journal file locations.
- Install the same sync client on each device and let it replicate the folder.
- Verify on the second device by opening the journal and checking that recent entries appear.
Choosing a sync tool
| Option | Good fit when | Main trade-off |
|---|---|---|
| Dropbox or similar consumer file sync | You want the least setup and already pay for storage | Sync client must run on every device; conflicts are handled by the service, not jrnl |
| Self-hosted sync (e.g. Nextcloud) | You want to keep journals on your own infrastructure | You maintain the server and clients |
| Git repository | You want full history and diffs of a plain-text file | Manual commits and merge conflicts; awkward on phones |
Dropbox is the concrete example named in jrnl's own material. Nextcloud is the usual pick if self-hosting matters. GitHub works if you prefer version control over continuous sync.
Two things worth deciding first
Conflict risk. Plain-text files synced by a file service can produce conflicted copies when you edit the same journal on two devices before syncing. If you journal on a phone and a laptop in the same hour, expect occasional duplicate files and plan to merge them. Editing on one device at a time largely avoids this.
Encryption. jrnl can encrypt journals with AES, which matters more once files leave your machine and sit in someone else's cloud. Note the page's own warning: lose the password and the content is unreadable, including to you. Decide whether you want encryption before you start syncing, since switching later means re-encrypting existing files.
A practical next step: open your journal's config, confirm exactly which file path each journal name points to, and move only those files into the synced folder. Then add one test entry per device and confirm it lands everywhere before trusting it with anything you'd hate to lose.
Can I use jrnl to manage separate journals for work and personal life?
Yes. jrnl is explicitly built for multiple journals, so you can keep work and personal entries apart while using the same command-line tool.
How separation works in practice
You create or name a journal, then direct each entry to it. A typical workflow looks like this:
- Write a work note:
jrnl work: Met with the design team about Q3 scope. - Write a personal note:
jrnl personal: Booked the dentist for Tuesday. - Read only one stream:
jrnl work -n 10to see the last ten work entries.
Because journals are stored as separate plain-text files, the two streams do not bleed into each other. You can also encrypt one journal and leave another unencrypted, or sync only the personal one to a service like Dropbox while keeping work local.
Choosing between one journal and several
| Approach | Best for | Trade-off |
|---|---|---|
| One journal with tags | People who search across everything and want a single timeline | Requires discipline with tags; work and personal content sit in the same file |
| Separate journals | Clear work/life boundaries, different encryption or sync rules per journal | You must remember which journal name to use on each entry |
A practical middle ground: use separate journals for the big split, then tags inside each one for projects or moods.
A concrete setup to try
Start with two journals, work and personal. For the first week, write at least one entry in each daily. If you find yourself constantly searching across both, consider merging them and relying on tags instead. If you never cross-search, keep them separate and consider encrypting the personal one.
For the exact syntax for creating, listing and configuring journals, see the official documentation at jrnl.
What are the advantages of jrnl's plain-text storage over proprietary journal apps?
Plain-text storage is jrnl's core design bet: your entries are ordinary files on your disk, not records locked inside a vendor's database. That changes what you can do with years of writing.
What plain text buys you
- Longevity. A text file needs no particular company to stay readable. Proprietary journal apps can shut down, drop formats, or force migrations; a
.txtor Markdown file opens in any editor decades from now. - Portability and no lock-in. You can move entries between machines, back them up, or switch tools without an export tool that may or may not exist. jrnl also points out you can sync the files with services like Dropbox.
- Search, diff and script. Standard tools like
grep,diff, Git and your editor's search work on journals directly. You can version entries, build your own reports, or pipe text into other programs. - Transparency. You can read exactly what is stored. There is no hidden schema, and no risk that a sync conflict silently discards an entry you cannot inspect.
- Composability with encryption. jrnl supports AES encryption for journals, so plain text does not automatically mean exposed text — you get readable files plus the option to protect sensitive ones.
The trade-offs are real: plain files have no built-in rich formatting, no mobile app with a polished UI, and no automatic conflict resolution. Syncing via a file service can create merge conflicts if you edit on two devices at once, and losing an encryption password means losing the journal.
A practical way to decide
If your priority is a durable, greppable archive you control, plain text wins. If you need embedded images, structured templates, or a polished mobile experience, a proprietary app may fit better. A common middle path: keep sensitive material in an encrypted jrnl journal and sync the files with a service you already trust.
For a concrete scenario, a developer who journals about debugging sessions can search years of entries with grep, commit the journal to a private Git repo, and read it in the same terminal used for work — without exporting anything. If you want to compare approaches, see jrnl for the plain-text model and Evernote or Day One for app-centric journaling.
Cloudflare
Fastmail
User reviews (0)