Niman

Shortcuts

Keyboard (desktop)

App-level accelerators, as Niman ships them. Settings → Keyboard shortcuts lists them and lets you change them:

  • Ctrl/⌘+Shift+P — the command palette: commands and notes in one search
  • Ctrl/⌘+O — go to a note by name (the palette, on notes alone)
  • Ctrl/⌘+Shift+O — open a Markdown file outside any library (see organization)
  • Ctrl/⌘+N — new note
  • Ctrl/⌘+Shift+N — new list note
  • Ctrl/⌘+Shift+A — new voice note
  • Ctrl/⌘+T — new todo
  • Ctrl/⌘+Q — quick note
  • Ctrl/⌘+Shift+J — today’s journal entry, made first when there is none
  • Ctrl/⌘+Shift+Page Up / Page Down — the journal entry before / after the one on screen
  • Ctrl/⌘+B — show or hide the sidebar
  • Ctrl/⌘+W — close the note on screen (its tab)
  • Ctrl/⌘+Tab / Ctrl/⌘+Shift+Tab — next / previous open note
  • Ctrl/⌘+\ — split the window right with the note on screen
  • Ctrl/⌘+Shift+B — show or hide the side panel (outline, tags, history, the journal’s calendar)
  • F11 — Zen mode: the note and nothing else; Esc or F11 again leaves it (see editing)
  • Ctrl/⌘+Shift+T — typewriter mode on or off: the line being written stays in the middle (see editing)
  • Ctrl/⌘+1…5 — Files, Todo, Search, Quick note, Settings tabs (on a wide window Settings opens as a floating window)

Formatting, in both editors, on the note’s selection:

  • Ctrl/⌘+B — bold, Ctrl/⌘+I — italic, Ctrl/⌘+U — underline
  • Ctrl/⌘+Shift+S — strikethrough, Ctrl/⌘+Shift+E — code block
  • Ctrl/⌘+K — link, Ctrl/⌘+Shift+H — heading level
  • Ctrl/⌘+Shift+L — bulleted list, Ctrl/⌘+Shift+D — numbered list
  • Ctrl/⌘+Shift+Q — quote
  • Ctrl/⌘+M / Ctrl/⌘+Shift+M — indent / outdent
  • highlight (==…==) has no key of its own as shipped: give it one in Settings → Keyboard shortcuts → Formatting

These do exactly what the toolbar’s buttons do, and they are changeable like the rest (Settings → Keyboard shortcuts → Formatting). They apply while an editor has the focus, and the app’s own commands keep off them, so a combination means one thing: Ctrl/⌘+B is bold inside an editor and the side panel outside one, the one overlap the two have always shared.

Moving and selecting in the source editor, on Windows and Linux:

  • Ctrl+← / Ctrl+→ — jump a word
  • Ctrl+Shift+← / Ctrl+Shift+→ — select a word
  • Home / End — start and end of the line, Shift to select
  • Ctrl+Home / Ctrl+End — start and end of the note
  • Tab / Shift+Tab — indent and outdent the line; in a table in live mode, the next and the previous cell instead

Reading a note in the read view (Markdown notes, with the unified engine), which takes the keyboard when you switch to it or click it:

  • ↑ / ↓ — scroll a line
  • PageUp / PageDown — scroll a page, keeping a line of the last one
  • Home / End, with Ctrl or without — start and end of the note

Editor find/replace follows the familiar bindings:

  • Ctrl/⌘+F — find
  • Ctrl/⌘+Alt+F, or classic Ctrl+H on non-mac desktop — replace
  • Esc — close the find bar
  • PageUp / PageDown — move in results

Links: Ctrl+click a link in the source editor to follow it.

Changing a shortcut

In the palette itself, Alt+P pins or unpins the selected command; pinned ones head it before anything is typed. On a phone the palette opens with two fingers dragged down, with the ⚡ on the Search tab’s bar, or from an open note’s ⋮ menu.

Settings → Keyboard shortcuts lists every command, with its keys or with No shortcut, and is where they change. Settings → Commands is the palette’s reference: the same commands, with when each one can run — the palette and the keys offer a command only where it can, so one that needs an open note is not there without one, and one that works on a note’s text (preview, tidy, history) is not there with a picture, a PDF or a book on screen. Nothing changes there: its keys are the ones set in Keyboard shortcuts and follow them, and tapping a key (or Change keys in Keyboard shortcuts) opens that command’s row there.

  • Change. Tap a command and press the new combination. While the window is recording it takes every key, Esc and Tab included, so leave with Cancel, or by holding Esc down. A key on its own is refused, because a plain letter is for typing; function keys (F1…F24) may stand alone.
  • Conflicts. A combination another command already has is never taken silently. The screen names that command and asks whether to move the keys; if you do, that command is left with no shortcut.
  • Keys the text fields and the editors use. Copy, paste, cut, select all, undo, redo, find, replace and the formatting keys may be taken, after a plain warning: your command takes them there too, outside an editor.
  • The Formatting group changes the same way, with its own conflicts: a formatting key collides with another formatting key, not with an app command, since the two apply in different places. A formatting key you moved stops working on its old combination in both editors. A key you give an app command wins over the formatting that has it, inside the editors too — your word is the last one.
  • Remove and restore. × removes a command’s shortcut. A command with none is still one Ctrl+Shift+P away in the command palette. ↺ puts back the key Niman ships, and Restore defaults puts back every one.

A key you chose wins everywhere, both editors included: Niman looks for it before the editor hears the key. The keys as shipped are chosen not to collide with the editor’s own.

The shortcuts belong to this device: they are kept in its settings, never in a library, so a library synced to another computer does not bring this keyboard’s keys with it.

Some combinations never reach an app. Win+anything on Windows, and the ones your Linux desktop keeps for itself, are taken before Niman sees them. Niman cannot tell which these are, so a shortcut set on one simply never fires.

The command palette

Ctrl+Shift+P opens one field over whatever is on screen. It searches the app’s commands and your notes by name at once:

  • Names. Commands are named Group: Verb, such as Editor: Switch to the WYSIWYG editor or Library: Re-index now. A trailing … means the command will ask you something before it acts (Note: Move…).
  • Keys. A command that has a key shows it beside its name.
  • Moving and choosing. ↑/↓ move through the list, ↵ runs the command or opens the note, and Esc closes the palette. The line at its foot says so.
  • Order. Before you type, it offers the commands you used last and the notes you had open. Once you type, what you used lately still comes first.
  • Only what works here. It lists the commands that can run where you are: nothing about the note when none is open, no panes on a phone.

Some commands have no key at all, such as renaming the note on screen or re-indexing the library: the palette is how you reach them.

On a phone the Search tab is the palette: whatever you type lists the matching commands above the notes found, and a tap runs one.

In the file tree, Ctrl+click a note (or middle-click its tab to close it) to open it in a tab of its own — see editing.

Launcher quick actions (Android)

Long-press the app icon for dynamic shortcuts (labels localized, published at startup):

  • Quick note — opens the quick note
  • Today’s journal entry — opens today’s journal entry, made first when there is none
  • New todo — opens the Todo tab’s add-task dialog
  • New note — the Files FAB’s “New note” flow
  • New list note — the Files FAB’s “New list note” flow (desktop tray and Linux launcher; Android launchers show the first four)
  • New voice note — the Files FAB’s “New voice note” flow (likewise)

Each shortcut runs the same flow as its in-app button, so the two can never drift.

CLI launch flags (desktop)

Desktop builds accept --quick-note, --journal-today, --new-todo, --new-note, --new-list, --new-voice, routed through the same handler as the launcher actions — and the tray menu lists the same ones.

The niman command is the package’s: the Arch package and the Linux tarball’s root launcher put it on PATH, while the AppImage and the Windows build are run by their own path — see platforms.

A path opens that file: niman ~/project/README.md opens it the way Open file does (see organization). A relative path is read from where the command was typed.

There is only ever one Niman per session. With Niman already running, niman <file> or niman --quick-note hands itself to that Niman, which comes to the front and does it, and the new launch ends without opening a window. That is also what keeps two processes from holding one library.

Edit this page on GitHub