Platform notes
Supported today: Android (minSdk 30, Android 11), Linux (Wayland), Windows, and macOS (14 and later) in preview — see macOS for what it still lacks. iOS and iPadOS (17 and later) run but are not released yet — see iOS. New tests must be portable too (see conventions).
Export is one feature on every platform: Markdown, HTML, PDF and EPUB are in both choosers, note and folder alike. EPUB is platform-neutral Dart — no engine, no WebView — so a book is built the same way everywhere; PDF goes through each platform’s own printer (below).
Kanban boards (kanban) are on every platform, drawn to the surface: columns side by side from a tablet’s width up, one column at a time under tabs on a phone, where a card moves from a sheet instead of being dragged across columns (#1154). A touch screen on a desktop moves a card with its menu or the keys; a finger’s drag there would take the column’s scroll. A board exports as a board on every platform (#1170): a wide one prints on A4 landscape through Edge or Chromium, Android’s WebView and WebKit alike, and through the drawn fallback.
Slide notes (slides) present on every platform, the screen
kept on while they do: Android through the window’s keep-screen-on flag,
Linux through GTK’s idle inhibit (the desktop’s own screen saver and
lock wait), Windows through SetThreadExecutionState, a Mac through a
power assertion. The presenter
view shares the one window with the slides: putting the slides on a
second screen and the presenter view on the first needs a second window,
which Flutter offers only behind an experimental flag on the desktops and
not at all on Android — a decision for now, not an omission (#534). On a
second screen, present from the window placed there.
A note’s columns (editing) are on every platform, in the read view, in live mode and in every export. A pane lays them out by the width it has, not by the device: on a phone’s pane they stack, in the order they are written; a tablet or a wide window sets them side by side. A PDF printed by the platform lays them out with the HTML page’s CSS, and the fallback that draws the pages itself by the app’s own rule: the two agree.
Android
- Android version: Android 11 and later (minSdk 30, the oldest with “All files access”; #1178). Below it the storage model would differ (legacy storage permissions), so it is out of scope for now. Before Android 14 the web-capture service runs untyped, so it has no three-minute limit.
- Devices: 64-bit ARM (
arm64-v8a). The released APK carries that ABI alone: 32-bit ARM was dropped for size (the native libraries came to 55 MB), and x86-64 is an emulator’s, which runs a debug build fromflutter runinstead (#1146). A decision, not an omission: an x86-64 device cannot install a release. - Storage: plain
dart:iofile access, gated byMANAGE_EXTERNAL_STORAGE. SAF tree grants are not a substitute — they only opencontent://, never the filesystem. - FUSE cost: every file stat/list is a round trip, so all disk reads
run off the UI isolate (
Isolate.run); Drift writes stay on main. The files allowed a synchronous file call, and the isolate each runs it on, are listed intest/unit/ui_isolate_io_test.dart(#1143). - Reminders: exact alarms fire with the screen off or the process killed. Grant notification permission and, in Niman’s App info page (Informazioni app), turn on Allow background usage (Consenti l’utilizzo in background) — an app the system will not start in the background never fires an alarm.
- Launcher shortcuts: long-press the icon (see shortcuts).
- Home-screen widgets: the Niman Todos, Niman Note and Niman Study widgets (see widgets). The Home-screen widgets switch in Features is shown on every platform, tagged Android: it travels with the library and acts where widgets exist.
- PDF and EPUB with the readers off: the file goes to the system’s app
through a read-only
content://grant for that one start, as the desktops hand over a path (see features). - PDF export: through the system WebView’s print adapter, in-process: no browser is installed or run, and the PDF’s text stays selectable. A folder’s PDF zip prints each note the same way, one PDF per note. A WebView that refuses the print (a broken system component) falls back to drawing the note page by page, pictures included; that PDF is a picture and cannot be selected, and the app says so when the file is written.
- Text recognition: the engine (64-bit ARM, or x86-64 for an emulator) is a 2.3–2.7 MB download, loaded from the app’s private storage; nothing ships in the APK. A recognition pauses when Android freezes the app in the background and goes on when you come back; the strip under the top bar follows it on any note (see text recognition).
- Web capture: a page is captured with Niman off screen, under a short foreground service and its notification; a page with too little text is run in a hidden WebView of the app’s own (see web capture).
- Link preview: there is no pointer to hover, so a long press on a link in the read view opens the note it points at as a bottom sheet with an Open button (see links). The editor has none: a long press there selects the word under the finger, and a tap places the caret. This is a decision, not an omission; Linux and Windows preview on hover.
- Paste as Markdown: in the editor’s menu. Android’s clipboard holds the HTML a browser copies but not the page it came from, so the paste is not linked to its page, and links written relative to it stay as the page wrote them (see web capture).
Linux
- Wayland supported; window owns close-request handling (dirty-check on close rides it).
- The app draws its own title bar — sidebar toggle, window title, and the minimise / maximise / close buttons — in place of the system one. The close button meets the same unsaved-edits check the system close does.
- Closing the window ends the process there and then, skipping the library teardown libc runs on the way out: on NVIDIA that teardown segfaults inside the EGL driver and left a core dump behind every close. Nothing of ours is skipped — the dirty-check ran, the notes are written and the engine is down before the window goes.
- Spellcheck via hunspell (
spellDictionariesin library settings), plus a per-library personal dictionary (right-click Add to dictionary,<library>/.niman/dictionary.txt). - The tray icon, where the desktop provides one. Its menu has Open Niman at the top, the quick actions (today’s journal entry among them), and Quit. By default the window’s × hides Niman to the tray and leaves it running, so desktop reminders keep firing; Settings → Appearance → Close to the tray turns that off, and then the × quits as it used to. Quit asks about unsaved notes exactly as the × does. On Linux the click on the icon is the menu — a StatusNotifier item has no right click of its own — and Open Niman is how the window comes back. On Windows the right click opens the menu and a left click brings the window back.
- Markdown files open in Niman: the desktop entry declares
text/markdown, so Niman is offered for.mdfiles and can be made their default app. Double-clicking one opens it in the Niman already running, or starts one. - The
nimancommand is the package’s, not the AppImage’s. The Arch package installs it at/usr/bin/niman, so it is onPATH. The.tar.gzships animanlauncher at its root beside the bundle: put the extracted folder onPATH, or symlink that launcher into~/.local/bin, to get the command. The AppImage puts nothing onPATH: run its own file with the same arguments —./niman-<version>-linux-x64.AppImage --quick-note, or./niman-<version>-linux-x64.AppImage note.md— or symlink the AppImage itself asniman. The flags are under shortcuts. - Updates are not looked for: Settings → Updates → Release page
opens the latest release. Download the AppImage, the
.tar.gzor the Arch package again, the one you run now, and replace it (#1270): an AppImage left in Downloads beside the old one is not what the launcher you use starts. - Dropping files and folders on the window is the window’s own GDK
drop destination, which takes the
text/uri-lista file manager offers. The frame around the window says a drag is over it, and the drop opens, imports or attaches what it names (organization); a web page asks whether to convert it, attach it or both. The portal’s file-transfer target is not taken: it carries a one-time key to resolve over D-Bus rather than paths, and preferring it is what left a drop on KDE/Wayland doing nothing at all (#224). A drag from a sandboxed app that offers that target alone is therefore not taken either, and says so in the log. - A tree row’s right-click menu can show the note in the file manager
(over
org.freedesktop.FileManager1, falling back toxdg-openon the folder) or open it in the default app — see organization. - PDF export: printed headless by the first Chromium-family browser
on
PATH— Chromium, Google Chrome, Microsoft Edge, Brave, Vivaldi, Helium: one engine under many names. On a machine without one, a note is drawn as pictures of its pages — pictures included, but not selectable — and the export asks before it starts, because a long note is minutes of drawing; a folder’s PDF zip is not offered. - Text recognition: the distribution’s Tesseract (4.1 or later) when it is installed, with no download; otherwise a 2.9 MB engine built for glibc 2.34 and later (see text recognition).
- Web capture: a page with too little text is run headless in the same Chromium-family browser, with a throwaway profile. Without one, such a page is saved as its title, description and picture, under a notice to open the link (see web capture).
- Paste as Markdown: the clipboard’s HTML is read through GTK, on X11 and Wayland alike; the page it came from is the one Chromium-family browsers and Firefox name beside it (see web capture).
Windows
- Ships its own SQLite (
sqlite3package bundles the native library via Dart build hooks — Windows has no systemsqlite3.dll). First build on a machine needs network to fetch the prebuilt binary. - Ships the Visual C++ runtime too (
msvcp140.dll,vcruntime140.dll,vcruntime140_1.dll, next toniman.exe), so the installer and the zip run on a Windows that never had the redistributable installed. A release build fails if they are missing. - spellcheck via hunspell, same setting as Linux, plus the per-library personal dictionary.
- The app draws its own title bar, as on Linux. The window keeps its
system behaviours — resizing from the edges, Aero Snap,
Win+Arrow — because the frame is still there underneath; the app only paints over the caption. - Hovering the maximise button opens the Windows 11 Snap Layouts flyout: the runner answers the hit test over the button’s rectangle, which the title bar reports on every layout it takes, so the flyout follows the bar’s real layout rather than a fixed spot (#169). The three buttons are non-client for that, so the app no longer draws their hover highlight on Windows; the × still meets the unsaved-edits check.
- The installer can associate
.mdand.markdownfiles with Niman (a checkbox, on by default). Niman joins the files’ Open with list; Windows leaves the choice of default app to you, so it becomes the default only when nothing else claims.md, or when you pick it. Double-clicking one opens it in the Niman already running, or starts one. - The
nimancommand is theniman.exein the install folder (%LOCALAPPDATA%\Programs\Nimanfor the per-user install). The installer puts nothing onPATH, so call it by path or add that folder yourself; the flags are under shortcuts. - Updates are not looked for: Settings → Updates → Release page opens the latest release, whose setup installs over this one (#1270).
- Dropping files and folders on the window takes the paths Win32
hands the window (
WM_DROPFILES), and the drop opens or imports what it names (a web page asks whether to convert it, attach it or both). The frame that Linux draws while a drag is over the window is not drawn here: reporting a drag that is over the window and has not landed needs an OLEIDropTargetregistered on the Flutter view, which this pass does not do (#224). The drop itself is unaffected. - A tree row’s right-click menu can show the note in Explorer (selected) or open it in the default app — see organization.
- PDF export: printed headless by Edge, found through the shell’s App Paths key or its install folder. A note falls back to being drawn as page pictures where Edge is missing — asking before it starts, as on Linux — and a folder’s PDF zip is not offered then.
- Text recognition: a 3.9 MB engine downloaded into the app folder, with the C runtime built in, so nothing else needs installing (see text recognition).
- Web capture: a page with too little text is run headless in Edge, with a throwaway profile (see web capture).
- Paste as Markdown: the clipboard’s
HTML Format, which the browsers write with the page it came from (see web capture).
macOS
Preview. The Mac is a desktop: what this page says of the Linux and Windows window — the density, the tabs in the title bar, renaming in a tree row, dragging into a note, opening a file outside a library, previewing a link on hover — holds there too. It stays a preview until the home-screen widgets reach it (they come after iOS’s), and the list at the end says what else it still lacks.
- Getting it:
niman-<V>-macos.dmgon the release page — open it and drag Niman onto Applications. One app for Apple silicon and Intel Macs. It is not yet signed with an Apple Developer ID, so on the first launch macOS refuses it: open System Settings → Privacy & Security and choose Open Anyway (a right click → Open no longer gets past it since macOS 15). - Updates are not looked for: Settings → Updates → Release page opens the latest release, whose disk image you drag onto Applications again to replace Niman (#1270).
- A library is any folder: the app is not sandboxed, so it reads and writes where the library is, as on Linux.
- The window: Niman’s own title bar beside the system’s traffic
lights. The × hides the window and the app stays in the Dock — a click
on its icon brings it back — and
⌘Qquits, asking first about notes with unsaved edits. There is no Close to the tray setting: closing already does that. - The menu bar holds every command, grouped as the command palette
groups them, each with its key; Settings is
⌘,. A menu item shows no key where the note needs that key first (⌘Bstays bold). Niman’s icon in the menu bar, drawn in the bar’s own black or white, opens the quick actions menu. Keys use⌘(see shortcuts). - Reminders for
todo.txtandcalendar.txtare scheduled with the system, so they arrive with Niman closed, as on Android; macOS asks for permission the first time one is set. - Spell check is the system’s own (the one TextEdit and Mail use), in the languages the Mac has; the per-library personal dictionary applies on top.
- PDF export goes through WebKit, the engine behind Safari: paginated A4 with real, selectable text, a note’s or a folder’s, nothing to install. Web capture runs a page with too little text in WebKit too, keeping nothing between captures (see web capture).
- Text recognition: the engine comes inside the app — a Mac loads only libraries signed with the app — and the languages are downloaded as elsewhere (see text recognition).
- Transcription reads WAV and, decoded by the system, m4a, mp3, AAC and the other formats macOS plays.
- Dropping files, folders and links on the window opens, imports or captures them, with the frame Linux draws while a drag is over it; a web page asks whether to convert it, attach it or both. Niman is not in Finder’s Open With for a page, as it is not for a book: drop it, or use the tree and the palette.
- A tree row’s right-click menu can show the note in Finder, selected.
- Opening a
.mdfrom Finder: Niman is in its Open With menu, as an alternate — the default stays the app you chose. Double-clicking a note set to open with Niman, or dropping one on its Dock icon, opens it in the Niman already running, or starts one. - The Dock icon’s menu holds the same quick actions as the menu bar’s icon.
- Paste as Markdown reads the clipboard’s HTML the browsers write: Safari, Chrome, Edge and Firefox, with the page it came from except from Firefox.
- Slides keep the screen on while they are presented.
- Date created is the file’s own creation time, kept across saves (see Date created).
Still missing on a Mac:
- the home-screen widgets.
The formulas’ smoother drawing that Linux and Windows get is off on a Mac by design: its renderer already smooths their edges.
iOS
Not released yet. The app runs on iPhones and iPads (iOS 17 and later), but is not on the App Store or TestFlight: that needs an Apple Developer account. An iPhone has the Android phone’s layout and an iPad the Android tablet’s — the layout follows the window, not the device — so what this page says of Android’s screens holds there.
- Libraries live in Niman’s own folder, which Files shows as On My
iPhone › Niman (On My iPad): each folder there is a library, and you
and other apps see its
.mdfiles. Creating a library makes a folder there; opening one lists them. A library leaves the device through Niman’s WebDAV sync or a copy in Files. A folder elsewhere — iCloud Drive, another app’s storage — cannot be a library: iOS gives such a folder’s files out lazily, which a large library cannot be scanned through. This is a decision for now, not an omission. Deleting the app deletes its folder, libraries included. - Updates come from the App Store once Niman is there; the app does not look for them itself.
- Reminders for
todo.txtandcalendar.txtare scheduled with the system, so they arrive with Niman closed, as on Android; iOS asks for permission the first time one is set. iOS holds at most 64 at a time: Niman schedules the 64 soonest of all of them, repeating events’ days included, and the later ones each time it runs after some of those have fired — nothing runs while Niman is closed. - Quick actions: press and hold the icon (see shortcuts).
- Opening a
.mdfrom Files or another app’s Share or Open in opens it in Niman, in place: a note outside a library opens on its own. - Spell check is the system’s own, in the languages the keyboards have; the per-library personal dictionary applies on top.
- PDF export goes through WebKit: paginated A4 with real, selectable text, nothing to install. Web capture runs a page with too little text in WebKit too (see web capture).
- Web capture starts from New ▸ Capture web page; iOS gives a capture under way about half a minute once you leave Niman, and its end is a notification (see web capture).
- Sync after you leave the app gets the same half minute (see sync).
- Text recognition: the engine comes inside the app — iOS loads no code an app downloads — and the languages are downloaded as elsewhere (see text recognition).
- Transcription reads WAV and, decoded by the system, m4a, mp3, AAC and the other formats iOS plays.
- Link preview is a long press in the read view, as on Android.
- Paste as Markdown reads the HTML Safari and the other browsers put on the clipboard.
- Slides keep the screen on while they are presented.
- A hardware keyboard gets the keys with
⌘, as on a Mac (see shortcuts). - Date created is the file’s own creation time, kept across saves (see Date created).
Still missing on iOS:
- Share → Niman from other apps — text, files and pages — which needs a share extension;
- the home-screen widgets;
- a release: TestFlight first, then the App Store.
Home
On Linux, Windows and an Android tablet the Home is a grid of tiles; on a phone it is a column of the same tiles. One Home, one file: only the shape changes. The grid asks for 640 px of room, and that is all it asks: a phone turned to landscape is a phone still, with the phone’s bottom bar and one screen at a time, but its Home has the room and so is the grid.
Density
On Linux and Windows the note tree and its right-click menu are drawn for a mouse: shorter rows, a narrower slot for the folder chevron and the note icon, and a tighter menu. Every other menu is drawn the same way — the ☰ menu, the note’s ⋮ menu, the tabs’ right-click menu, the editor’s and the reader’s context menus, the pop-ups that stand in for a sheet: 32 px rows, small icons and the label in body text. A phone or a tablet keeps the thumb-sized rows and the long-press sheet. The choice follows the platform’s own density (compact on a desktop), not the window’s width, so a tablet in landscape keeps the touch sizes. That holds for the wide layout’s own chrome too (#849): on a tablet the rail’s destinations, the open notes’ tab row and its buttons, the tree footer’s buttons and the grab strip of the dividers between the panels are at least 48 px, where a mouse has them smaller (the rail’s at 38, the divider’s strip at 8). In the narrowest tree the footer’s buttons scroll rather than shrink.
The folder grid
The grid of a folder ships on every platform; the shape adapts to the surface. A wide window shows the breadcrumb where the tree’s first row would be, three or four columns in the sidebar — two at its 200 px minimum — and the List | Grid pair at the foot, beside the sort chevron. A phone fills the screen with the same tiles, three or four columns, puts the breadcrumb under the app bar, keeps the switch at the top of the sort menu, walks up one folder with the system Back, and opens the row sheet on a long press — renaming stays the dialog there, as it does in the tree.
Window size
The Linux and Windows window cannot be made narrower than 600 px — the width at which the layout would switch to the phone’s bottom bar and full-screen note — nor shorter than 400 px. A window snapped that small is still driven by a mouse, and the desktop keeps its rail, tree and panes down to the floor. On Windows the floor counts the window’s thin frame on top of those 600 px, so the app’s own area keeps all of them at any display scale.
On Android the layout follows what the device is, not how wide it is turned (#849). A window whose shortest side is under 600 dp is a phone, and has the phone’s layout on both orientations: the bottom bar, one destination on screen at a time, a note as a page whose Back closes it, and Settings as a tab. Turned to landscape it is that same layout with more width for the note — there is no third layout, and turning the phone keeps the open note, its undo, the find bar and the search where they are. A window whose shortest side is 600 dp or more — a tablet, a phone in Samsung DeX or on an external display — has the wide layout: the rail, the tree, the panes and the tabs. The line is the window’s shortest side, so a tablet in split-screen that leaves it a phone-sized window has the phone’s layout there, and the wide one again when it has the room back. The tree’s width, the side panel’s width and the saved split are the wide layout’s alone; a phone leaves them as they are and a library saved on a phone and opened on a tablet finds them untouched.
The wide layout on a touch device keeps what a touch device needs of it: nothing under the status bar, the gesture bar or a camera cutout; the system Back stepping inside the app (below); and the command palette by two fingers, there being no key for it.
Its rail is a tablet’s (#1266, the mockups): each destination shows its name under its icon, there being no hover to read a tooltip by; the library sits at the rail’s top, its initial on the accent, with New under it — the tree footer’s create menu, where a thumb on the left edge finds it — and Settings at the foot. With the keyboard up, or wherever the rail is too short for them, the names go and the icons stay, the rail keeping its width so the note beside it does not move; what still does not fit scrolls, so Settings and the library stay within reach. A desktop’s rail is icons only, their names in the tooltips.
On a tablet held upright, or in landscape where the tree beside the note would leave the note less than 360 dp, the tree lies over the note instead (#1266): closed until the sidebar’s toggle, Files, Search or Study opens it from the rail’s edge, a scrim over the rest. A tap outside it closes it, and so do a note opened from it and Back; the search in it keeps its query while it is closed. Turned back to landscape, the tree is beside the note again if it was there. Writing is the note and the keyboard: while the keyboard is up in a note, the tree steps aside the same way, and comes back when the keyboard goes — typing in the tree’s own search leaves it where it is. A desktop’s tree is always beside the note.
Destinations
On a wide window (the desktops and an Android tablet; a phone is never one, turned or not) the rail’s destinations are not all the same shape. Files, Search, the tag tree and Study are sidebar views: they swap what the left panel shows and leave the open notes, the panes and the right panel where they are. Home and Todo are content destinations: they open as a pinned tab in the focused pane — the chip at the far end of its tab row, so opening or closing it moves no note tab — and the tree stays beside them, so a note is one click away while the list or the grid is up. On a tablet they are pages that want the width (#1266): the tree steps aside while one shows, the sidebar’s toggle lays it over the page, and a note opened from it takes the pane back with the tree beside it again. Closing the tab (its ✕) leaves the notes. Home or Todo on screen when a window grows from narrow to wide becomes that pinned tab. A phone keeps its one-screen-per-destination model, and the Search sidebar’s tag tree is the two-level list there (settings). A flashcard review opens as a tab of its own beside its deck on a wide window and full screen on a phone (flashcards).
Date created
The tree’s Date created order reads the creation time Windows, macOS and iOS keep for every file. A save writes the note to a temporary file and renames it over the note; the system would give the note the temporary file’s creation time, so the save first copies the note’s own onto it, and an edited note keeps the date it was created. Linux and Android report no creation time through the file API the app uses, so there Date created is the last modification time — a decision, not an omission (#726, #759).
Renaming
On Linux and Windows a note or a folder is renamed in its tree row (organization). A phone keeps the dialog: the tree and the note are not on screen together, and a row is too short to type in comfortably. A decision, not an omission.
Dragging into a note
On Linux and Windows a file dragged from the tree onto an open note
writes a link to it (links). A
phone shows the tree or the note, never both, so it has nothing to drop
onto: there the link is written from the note, with the link button or
by typing [[ and picking from the panel. A decision, not an omission.
Open notes
On Linux and Windows the open notes are tabs in the title bar, and the ones you were working in come back when you open the library again — see editing. The desktop window also splits into two panes, each with its own tabs.
On an Android tablet, or any wide window without the app’s own title bar, the same tabs head the notes instead of sitting in the title bar. There the row also holds what the title bar and the keyboard give a desktop: it starts with the sidebar’s toggle and the back and forward arrows, and ends with the side panel’s toggle — with a note open or none, each a thumb’s size, filled while its panel shows. The arrows are greyed at the ends of the history rather than hidden; a row too narrow for them and the tabs (a small tablet with the tree and the side panel open) leaves them out until there is room. A line over the tree names the library and the folder the selection is in, with the library switch beside it; on Linux and Windows the title bar says it. The row at the top of each note — its ⋮, and on a tablet its Edit | Read pair in the place of the status row’s eye — is a thumb’s height there too (#1266).
On an Android phone the same open notes are reached from a switcher instead of tabs: a count on the note bar opens the list. One note is on screen at a time, and the phone has no split: a phone’s width holds one note, in landscape too. With no tabs there is no new tab either: the switcher’s New note makes a note, and a phone with no note on screen shows its tree, which is its way in. The phone keeps at most 30 notes open: opening one more closes the one shown longest ago that has no unsaved edits, and it opens again where you left it.
Back and forward through the notes looked at work everywhere from a
keyboard (Alt+← / Alt+→), and on a tablet from the tab row’s arrows.
The mouse’s side buttons do it on Linux and Windows; on Android a mouse’s back button is the system’s Back, which
keeps its meaning — closing the note, leaving a screen. On a phone that
is the note’s page, a screen opened from the navigation, the folder the
grid is in; on a tablet’s wide layout it takes the topmost thing off the
screen, one step at a time: a book out of full screen, a pinned Home or
Todo, the search in the sidebar, the open note (the focused tab), and
last the grid’s folder. With none of them left Back leaves the app.
The command palette is Ctrl+Shift+P on the desktop. On a phone or a
tablet it is its own thing, apart from the library’s search: two
fingers dragged down anywhere open it, and so does Command palette in
an open note’s ⋮ menu, and on a phone the ⚡ on the Search tab’s bar. The
Search tab searches notes. Either way the palette offers only the
commands that can run where you are; Settings → Commands lists them
all, with their keys and what each one needs to show (an open note, a
wide window, the desktop, and so on).
On a device that has never had a hardware keyboard, nothing mentions keys you cannot press: the palette’s rows and Settings → Commands drop the key column (what a command needs is still there), and the palette’s footer says the pin is a tap. Plug a keyboard in and they come back.
Typing in the palette also finds settings, listed after the commands and the notes: pick one and the settings open on that row. The rows of the keyboard and Commands pages are left out, since the palette already lists those commands itself.
Pinned commands head the palette before anything is typed, above the
ones used lately. The pin on a command’s row pins and unpins it, and
Alt+P does the same to the selected row. Pins belong to the device,
like the shortcuts, and a pinned command still shows only where it can
run.
Keyboard shortcuts can be changed wherever there is a keyboard: on Linux and Windows, and on Android with a hardware keyboard attached, the same screen under Settings. Without a keyboard the screen says so instead of opening.
Zen mode (F11, see editing) is Linux and
Windows only. It needs the app’s own title bar, which is where its thin
bar goes, and a phone is already one note on one screen. The window is
maximized for it; if the window manager declines, Zen still hides
everything but the note.
Dropping files and folders on the window (see organization) works on every platform. On Linux, Windows and macOS the window takes files and folders from the file manager, and draws a frame while a drag is over it — on Windows the window’s drop target is OLE’s (#531). On Android and iPadOS a drag comes from another app beside Niman (split screen, DeX, ChromeOS, Stage Manager): there the drop takes files, which it attaches to the note on screen (#1250), not folders or text; a web page saved as a file asks first whether to convert it into a note (organization), attach it or both (#1293). A passage selected in a browser is text, and is not taken. A link dropped on a desktop window is a web capture; on a phone, the browser’s Share does it.
Importing a folder (see organization) is Settings → Maintenance → Import a folder on every platform, and a drop on the window on Linux, Windows and macOS. What the picker gives depends on the platform:
- On Linux, Windows and macOS it is the system’s folder dialog.
- On Android it is the system’s folder picker, read by path as a library is, so it needs the same all files access; Niman says so when it is missing. A folder dragged from another app is not taken (a drag there carries files, not folders): use the row in Settings.
- On iOS and iPadOS the picker lists the folders in Niman’s own folder (On My iPhone › Niman in Files), as opening a library there does: put the folder there with Files first. iOS gives the app no access to a folder picked anywhere else — iCloud Drive, another app’s storage — so it cannot be imported from where it is. This is a decision, not an omission. The library itself is in that list; picking it shows it, importing nothing.
Opening a file outside any library (Ctrl+Shift+O, see
organization) is
Linux and Windows only for now: Android’s picker hands over a copy of
the file, which could be read but not saved back.
Sharing into Niman (Android) goes the other way: another app’s
Share menu offers Niman for text and for a Markdown file, and a file
manager’s Open with does for a .md. A web page or a passage of one
shared from the browser opens the web capture sheet,
saved in the background with Niman off screen. Other shared text is
appended to the
quick note
and the note opens; with no quick note chosen yet, the choose/create
screen opens and the text lands in whatever note it picks. A shared file
is copied into the library as a new note — its name kept, uniquified
like any other — where the library’s setting for
new notes puts it (the
root when no note is open), and opened. A copy, because Android hands the sender’s
file as a read-only content:// reference, not a path Niman could edit
in place. A Notion export (a .zip) shared the same way is
imported instead of copied
as one note, a book (.epub), shared or opened with Niman from a file
manager, is converted into notes,
and so is a web page (.html, .htm, .xhtml) —
into a note — told by
its name, or by how the file begins when the sender gave it none. That copy is made in the background, so the app stays
responsive while a large share is read, and it is capped at 512 MB: past
that the share is refused rather than copied — the sender’s text arrives
instead, if it attached any.
The side panel (outline, the spelling review, tags, the notes that link here, the tasks that link it, history beside the note, and the journal’s calendar) docks beside the note on any wide window at least 1000 px wide: desktops and tablets. A narrower wide window keeps the panel’s button and opens the panel over the note instead (see editing). A phone, upright or turned, has no room for a note and a panel side by side, so this is a decision rather than an omission: the note’s status row keeps its outline and spelling buttons there — both open as sheets — and the ⋮ menu opens the outline, the tags, Links to this note and Tasks for this note as sheets, the history as its screen. On a wide window the status row also counts the notes and the open tasks that link the note — a link icon and a task icon with a number each, before the word count — and a click on one opens its pane in the panel; a phone has no counts, and the ⋮ menu’s sheets are its way to the same lists. Where the panel shows, its left edge drags to make it wider or narrower, like the tree’s edge. It stops growing before the note gets narrower than 360 px, and it keeps its width for the next launch.
Reading a book aloud
Android only, for now — a decision, not an omission (#1276). A book is
read aloud there with the device’s own text-to-speech engine
(android.speech.tts.TextToSpeech, the one TalkBack speaks with; Niman
adds no library and downloads no voice), under a media notification and
the lock screen’s controls — see
organization. iOS and macOS
(AVSpeechSynthesizer), Windows (the system’s speech API) and Linux
(speech-dispatcher) all have an engine of their own and may get read
aloud later; until then the button is not on the book’s row there.
Where an export’s dialog opens
A library can have its exports’ save dialog open in its own folder (Settings → Folders and paths → Export folder, #1286):
- On Linux and Windows the dialog opens there, for a note and for a folder’s zip alike.
- On Android the system’s picker starts there when a note is saved,
for a library on the shared storage — by whichever of its paths it was
opened,
/sdcardincluded, and a work profile’s own — or on an SD card. A library in a folder no storage provider names opens where the system chooses. The folder picker a zip is placed with takes no starting place, so the system chooses for it. - On macOS and iOS the system chooses: the picker Niman opens there is not told where to start. This is a decision for now, not an omission, and it may change later.