Juie
Contents

Juie guide

Juie is notes, a task tree, a board, a calendar and free-form canvases in one app. They are not four apps sharing a folder: a task you drag in the calendar is the same task in the tree and on the board, not a copy of it.

The layout

On desktop there are four columns: tags and shelves, the note list, the main area, and the task tree. The side panels fold away with the arrows at their edges. On a phone the main views switch from the bottom bar — the fourth button opens a sheet with the rest — the left panel opens as a drawer, and tasks are a view of their own. A tablet turned sideways keeps the desktop arrangement; upright it keeps every main view in the bottom bar and shows the list beside the note. The note header can replace the list with the outline or the tasks column. A phone turned sideways keeps a thin rail on the left; while you write, the list, the note's header and its tag row step aside for the text. Tasks are one column on every screen: opening a task replaces the tree with its page. On a phone, a swipe from the left edge closes the open note or task page, like Back.

The buttons above the main area switch between the note, canvases, the board, the calendar and cards. Views you don't use can be turned off in settings; notes always stay.

The interface language is in Settings → Interface: English, Русский, Қазақша and Qazaqsha (Kazakh without diacritics). It applies to the app, never to the text you have written. If you have not chosen one, Juie opens in English.

A new space opens empty. Juie does not write welcome notes into your workspace.

Notes

The + next to search creates a note. The title comes from the first heading, or the first line with something in it. Typing is saved as you go — there is no save button.

The list shows the title and the beginning of the text, most recently changed first; you can also sort by creation date or alphabetically. A pinned note stays above the rest and is ordered by hand whatever the sort says.

The row's context menu pins, archives and deletes. On desktop it also opens the note in its own window — the same session and the same space, so no password is asked again. That window has the editor, tags and backlinks, and a "keep on top" button in its title bar. Clicking the Juie wordmark opens a random note.

The archive keeps notes indefinitely. The trash empties on a schedule. Both can give a note back; deleting for good also removes the note's body from the local database.

Markdown and the editor

Text is stored as ordinary Markdown: headings, bold, italic, strikethrough, links, quotes, lists, checklists, code and tables. The editor's context menu toggles bold, italic, strikethrough, inline code, lists and checkboxes, sets a heading level (Heading › 1, 2, 3 or plain text), and the usual Cmd/Ctrl shortcuts work. On a phone the same actions sit in a row above the keyboard — undo, heading (tap again for the next level, a fourth tap for plain text), bold, italic, link, [[ note link, checkbox, list, template, find and, when the selection holds tasks, moving them to the tree; a long press is the system's own selection with its Copy/Paste menu, as in any text field. A trailing newline caught by a selection is left outside the markers. A backslash makes a Markdown character literal — \*not italic*, and \[\[not a link]] for double brackets.

Two editing modes in settings:

Aa switches reading mode for the whole app, keeping your place in a long text. Cmd/Ctrl+F searches inside the open note; the panel sits at the top so a phone keyboard cannot cover it. Text direction follows the content, so Arabic script reads right to left where it should.

Outline, versions, publishing

The outline is built from the open note's headings and jumps to a section. On desktop it opens in the tasks column's place, the same width, so with the tasks showing the text stays put; with the tasks hidden it opens that column, the way showing tasks would. Close it and the tasks return. On a phone it is a drawer from the right edge. Version history saves a state about once a minute and when you leave a note; a saved version can be compared with the current text and restored.

Publishing makes a separate public snapshot. Anyone with the link can read it, so publish only what is meant to leave the encrypted space. Nothing else — other notes, version history, space keys — goes anywhere near the publishing layer.

The snapshot never follows your draft on its own. After an edit Juie marks it outdated and waits for you to update it deliberately. The same dialog copies the link or takes the page down. The Published shelf and Settings → Account list what the account currently has online, including pages whose note is no longer on this device.

Deleting a published note takes its page down first. If the server cannot be reached, Juie says so rather than quietly leaving the page up; you can still confirm, and the takedown is retried later. Such a note stays in the trash longer than the usual thirty days. Deleting a space takes down the publications of that space — pages belonging to another, locked space have to be taken down from Settings → Account first, because their data is not loaded.

A wiki link on a public page opens its target when that target is published too; otherwise it stays plain text. Publishing or withdrawing the target marks the source outdated so you can update it on purpose.

External images stay external — Juie neither stores nor proxies them. Inside the app one loads only after a click, because the request tells another server your address and the time. On a public page it loads normally: the reader has already opened public content.

Publishing needs a Juie account. The rules are short and are at Publishing rules; moderation, reports and what happens after three takedowns are described there.

Wiki links, backlinks, tags

[[Note title]] links to another note, and [[Note title|what you see]] gives it a label. In reading mode the link opens on click. If the target does not exist, Juie offers to create it; if several notes share a title, it asks rather than guessing.

Above the open note's tags are its backlinks — the notes pointing at it. The index is derived, so plain Markdown stays portable and the links can be rebuilt after an import or a restore.

Tags form a tree, with a slash for nesting: Work/Juie sits inside Work. A branch can be collapsed, renamed, dragged to another parent or deleted from the context menu; deleting a tag never deletes notes. A note made while a tag is open carries that tag, so a tag can be worked like a folder. Dragging a note onto a tag adds that tag — the note does not move and can carry several. "Untagged" shows notes with none. Branches start closed; clicking a closed tag both opens it and filters by it, while the arrow beside it only opens and closes. The collapse button closes everything if anything is open, and only then expands.

Tasks

A task is either on its own or inside a project, with one level of subtasks below it. A project is not itself something to finish: it has a name, a quiet colour of its own and a count of what is done. The field at the bottom of a project creates a task inside it.

Projects can sit under group headings — "Work", "Study", "Life" — to find them faster; a group changes nothing else, not the board, the calendar or the tasks. On a computer, rest the pointer in the gap above a project and press "+ Start a group here": that project and the ones after it go under the new heading. Anywhere, Edit in a project's menu has a Group field: pick a group or type a new one, clear it to take the project out. Dragging a project next to another puts it in that group. Click a heading to fold or unfold it; its menu renames it, and "Remove group" returns its projects to the section above.

The arrow opens a branch, the checkbox finishes a task, and clicking the row opens the task as its own page — growing out of the row you tapped rather than replacing the screen. Dragging changes both order and parent within the allowed depth; a drop inside your own branch, or anything that would make a loop, is refused.

The search button turns the new-task field into a filter over the tree, matching project names and task titles. A nested match keeps the ancestors you need to find it and hides everything else. Escape, or the button again, goes back to creating tasks — an unfinished draft is kept.

Completion is stored apart from the due date. After the checkbox a day appears as YYYY.MM.DD; clicking it shows the exact time. Unchecking removes the mark, finishing again makes a new one. The date you planned and the day it happened do not have to agree.

The task context menu — everywhere it appears — opens, renames, completes or reopens, sets a date, makes iterations, archives and deletes. An open task can also be linked to the note you have open; one task can be linked to several notes, and unlinking asks twice.

Archiving, deleting and restoring a parent applies to its whole branch, and the same is true of a project: it goes to the archive or the trash with everything in it, and comes back in one move.

Cycles

An ordinary finite task can become a cycle: give the repetition a name and a count, and Juie makes iterations like Round 1, Round 2. An iteration opens as a page, but its generated title cannot be renamed separately. It cannot become a parent or leave its cycle. Change the cycle's repetition label to rename all of its iterations together.

Cycles do not mix with ordinary subtasks. The name and the count can change as long as shrinking would not remove iterations already in use. The board shows neither cycles nor iterations; the calendar shows the iterations, not the cycle.

Board

The board is assembled by hand. Put a root task on it from its context menu, create one in a column, or drag it from the tree onto a column; use the menu again to take it off. Adding or removing subtasks does not change board membership, and nothing arrives on the board by itself. A task with subtasks appears as one card with a progress count — "3 of 7" — in To do, In progress or Done. Subtasks, cycles and iterations are never cards of their own. Dragging between columns changes status, dragging inside a column sets order by hand; a task dragged in from the tree lands where the line shows, between the cards it was dropped on, and so does a task dragged onto a day in the calendar. Done shows the ten most recently finished. Opening a card — here or in the calendar — opens the page it lives on: a subtask's parent, a root task's project, or "Without a project" for a root task that has none; the task is highlighted among its neighbours.

A card carries the colour of its project, so you recognise work before reading it. You can create a task straight in a column, open a card, use its context menu, or drag it onto the archive or trash in the right panel. Dragging a card into the task tree changes only where it sits in the tree — its date and status stay as they were.

Calendar

The calendar plans by whole days; there is no hourly time-blocking. Day, three days, week (shown as two weeks), month and year are available, and which of them you get is up to you. The three-day view puts today in the middle, between yesterday and tomorrow. The week starts on Monday or Sunday, as you prefer. In the two-week view, the following week is a compact reference row: you can inspect or move its existing tasks, but add new ones in the current week or another calendar view.

Settings also offer a computed Hijri calendar beside the Gregorian one. The due date is stored as the same YYYY-MM-DD day either way, so switching changes only the months, the year and the labels on screen — never your plans, your exports or your sync.

Dragging a task onto a day sets the date; between cards of one day it sets the order; onto archive or trash it takes the task away. While you drag, a line shows where the card will land. Dragging a card into the task tree moves it in the tree and leaves its date alone. In the week and month views, where the cards are too narrow for a checkbox, the context menu finishes a task.

Long titles are readable where there is room: two lines in the tree, five on the board and in the day and week calendar, one in a month cell — with the full name on hover everywhere. A month cell lists every task of the day and scrolls when they do not fit. Finishing a task does not give it a date: a dateless task stays dateless, done.

The "no date" shelf shows each cycle's next unfinished iteration first, labelled Cycle / Iteration, then the nearest available tasks. The overdue shelf works the same way and closes when nothing is overdue. The year view counts finished and remaining tasks per day, and a month's name opens that month.

The calendar keeps archived tasks. Finished branches leave the tree and the board for the archive on their own after ten days, and the calendar would lose them too — which made it useless as a look back: the year's numbers stopped adding up and an old task could not be found. Archived means kept for good but no longer current; the calendar is exactly where "kept for good" matters. The trash is not shown.

Templates

A note tagged templates is a template. "Insert template" — in the editor's context menu, or in the note menu on a phone — puts its text at the cursor, on a fresh line, with {{date}} and {{time}} filled in. A workout log is the case it was made for: one template per training day, and an entry is insert, then type the numbers. Subtags group templates the same way they group decks.

For a note you only ever add to — a weight log, a diary — choose "Open at the end" in the note's menu (the row's context menu on desktop, the note menu on a phone): it opens with the cursor after the last line. Typewriter, the three-lines button next to Focus on desktop, is a separate setting: the line you are writing stays in the middle of the screen. Both are remembered per note.

A heading folds: point at its line and a chevron appears in the margin; click it and the section up to the next heading of the same or a higher level folds away, marked with "…" after the heading. Click the chevron or the "…" to unfold. Folds are remembered per note on the device. Tab nests a list item and Shift+Tab unnests it; outside a list, Tab indents by two spaces. Press Escape and then Tab when you want to leave the editor by keyboard instead. List items are set in the text's own ink — only links are coloured.

Cmd/Ctrl+F opens a find bar above the text: type to search, Enter and Shift+Enter step through matches, the count shows where you are. Case, whole word and regular expression are the small toggles on the right; ⇄ reveals replace. Esc closes the bar, and so does going back to typing in the text.

Focus, the circle-with-a-dot button beside the note's back and forward arrows, hides the library, the notes list and the tasks column together. The header keeps only the note's tools — exactly where they were, under the pointer that clicked — with the note's title on the left and the reading, history and outline buttons on the right. Press the button again or Esc to get everything back. Focus belongs to the note: opening the calendar or the board from a search shows their columns as usual, and returning to the note resumes it.

Zotero

Annotations copied out of Zotero's PDF reader arrive as quotes with a link of the form zotero://open-pdf/library/items/KEY?page=18. Juie keeps these links: in reading mode and on published pages they open Zotero at that page on any computer with the same synced library, and the page number from the address is shown beside the link, since Zotero itself leaves it out of the text. If you want the citation with author, year and page inside the quote, make the note in Zotero first — right-click the item, Add Note from Annotations — and copy that note (Settings → Export → Note format: Markdown).

Cards

A deck is a note tagged cards, or any tag under it: "Make a deck" in the note's menu adds the tag. Nothing in the text changes — only lines written as cards start to count as cards, and the rest of the note stays what it was, so a deck can also be the notes it was made from. Headings divide a deck into sections.

Subtags group decks: ten lecture notes tagged cards/biology show in the Cards view as a biology group, with each lecture its own deck; the group has its own Review and Practice, and a deck can be dragged into another group (that only changes its tag). A deck tagged with bare cards sits ungrouped at the top. In the tag tree, cards and templates cannot be renamed, moved or deleted, because the app finds decks and templates by them; their names change in Settings → Interface → Service tags, and every note follows. Everything beneath them is yours.

Three ways to write a card:

Capital of Kazakhstan :: Astana

What is a CRDT?
?
A data structure that merges without conflicts.

The Kazakh ASSR was formed on {{26 August 1920}}.

A one-liner has :: with spaces on both sides — std::vector in a note about code is not a card. A longer card is a paragraph with a lone ? between the question and the answer. A line with {{…}} is a cloze: the question shows the line with gaps, the answer shows it whole. Several gaps on one line are one card. In reading mode and on a published page a deck's cards are drawn as cards, with the gaps highlighted.

The Cards view lists your decks with how many are due, and runs a session: question, "Show answer", then three buttons — Forgot, Hard or Remembered. Hard means remembered, but only just: the card comes back sooner and is not counted as a lapse. A forgotten card comes back later in the same session until you remember it. Space reveals, ← is Forgot, ↓ is Hard, → is Remembered. A revealed cloze fills its gaps in place.

Practice runs through every card of a deck or group without writing anything to the schedule — for going over a deck again the same day, or before an exam. "Practice everything" is on the gallery; a deck with nothing due starts practice when clicked. A deck note has a "Review" button in its toolbar that opens the view on that deck.

Progress lives in the note, at the end of a card's first line:

Capital of Kazakhstan :: Astana // 260920 4 2

That is the next date, the interval in days, and how many times it was forgotten — all a spaced-repetition schedule needs. The interval grows on Remembered and resets on Forgot; a card forgotten often grows more slowly. Because the record sits on the line itself, it moves with the card when you edit the question, reorder the deck or copy the note elsewhere, and the note carries its own progress into backups and exports. Reading mode and published pages hide it. To reset a card, delete its tail.

Canvases

Canvases live in their own gallery and do not mix with notes. On an endless surface you place live cards of notes and tasks, text, groups and links between them, with pan and zoom, fit-to-screen, 100%, and colours for cards and groups. Deleting a canvas from the gallery asks twice and does not delete the notes and tasks on it.

The + in the canvas toolbar opens the palette: type to find a note or task to place, or make a new one right there — the first two rows create a note or a task with what you typed as its title. A click activates a card for editing; an inactive note card shows rendered Markdown and stays easy to drag. A task card shows its tree and changes the real tasks, not a copy. The canvas you had open and where you were on it survive switching views.

Search

The field above the note list filters that list. If the query also matches tasks, a link to the general search appears below.

Cmd/Ctrl+K searches notes, tasks and canvas names at once, grouped by kind. A note opens in the editor, a task in its place in the tree, a canvas on its surface. A task's checkbox can be ticked straight from the results.

Import, export, backups

Settings → Data holds the .juie snapshot, Markdown export and Markdown folder import. A .juie file carries the app's structure to another device. The export makes one folder named after the space and dated, with ordinary .md files inside. The import suits an Obsidian vault: subfolders become tags, and frontmatter and wiki links are kept.

Without a folder, a device-only installation reminds you every three days to save a copy by hand — its only copy is on that device. With an account the reminder stays quiet: the server keeps a copy. A local one is still worth having (it survives your own deletions). Save one with the backup button, or choose a folder for automatic copies where the platform supports it.

Where folder access is supported, automatic backups run into a folder you pick while the app is open:

A backup covers every readable space in the installation, not only the one you have open. If a space is locked or unreadable the backup fails visibly — Juie will not label a partial file as a safety copy. Both older single-space files and complete installation files can be imported. Restored records get fresh identifiers, so a newer deletion in the cloud cannot quietly remove them again — which does mean anything that survived appears twice.

On desktop, backup folders are limited to ones chosen through the system picker, and Juie remembers those for later copies. Make a manual copy before an import or a restore.

Choosing "sign out and remove this device's copy" produces a verified backup download first, and only then stops syncing and deletes the local databases. If the backup cannot be made, nothing is deleted and you are told why.

Account, spaces, encryption

Juie runs without an account at all: the first screen offers "this device only". Nothing leaves the machine, and the space is protected by a password you choose.

A Juie account is what puts your notes on more than one device. You invent the login yourself — no name, no email. From it comes a sign-in id like login-1234; the four digits are always added so everyone's looks the same. Write it down, because it is what you type on a new device.

The password never reaches the server. Two different keys are derived from it on your device: one proves at sign-in that you know the password, the other wraps your keys and never leaves the device. The server cannot open anything it stores, even holding everything it has.

The twelve-word phrase is shown once, at registration. Write it down somewhere other than the device: neither Juie nor the server can recover it. It does two things — opens a device without changing anything, and resets a forgotten password. They are separate items on the sign-in screen.

A new device needs nothing carried over. Enter the id and the password and every space key is rebuilt. The key files older versions needed are gone.

Each space has its own random master key. Databases, the search index and synced updates are encrypted with AES-GCM, and document names are hashed, so the server does not see even the titles. What it does see is the account, sizes and times.

Unlocking works offline: the password is checked on the device, and spaces it already knows open with no server at all.

On a computer Juie is not quit by closing its window, so the password is asked only after a real quit or a restart: on Windows the window goes to the tray (click the icon to return, "Quit Juie" in its menu to quit), on macOS Juie stays in the Dock (Cmd+Q quits).

On Android the password can be replaced by a fingerprint: tick "Unlock with fingerprint next time" on the unlock screen and confirm with your finger once. The password is then kept on the phone, encrypted with a key the system releases only after a fingerprint check; nothing leaves the device. If the fingerprints on the phone change, or the password changes, it is asked for once more. Settings → Space turns it off.

Spaces belong to the account. One made on any device appears on the others at their next unlock, or as soon as the space switcher is opened. Deleting a space removes it from the account — it needs the server for that and refuses without it. On your other devices it leaves the list at their next unlock, but not the disk: for thirty days it sits in Settings → Spaces as "removed on another device", where it can be restored (as a space of that device alone) or deleted now; after the term it is deleted for good. Juie erases a space's documents on the server before removing its key, and retries interrupted deletion after the next sign-in. A closed space first seen by an older version may need to be opened once before it can be deleted, so the current version can record its opaque document list without revealing titles to the server.

You can delete the account yourself in Settings → Account, confirming with the password. Notes, keys, devices and published pages go. It cannot be undone. Signing out is a different thing: it removes nothing from the cloud or from other devices, and comes in two forms — keeping this device's notes or removing them.

Unused accounts are removed after a while. An account has no email, so there is nobody to warn — this paragraph is the warning. An account that holds data is removed after two years without a sign-in from any of its devices; an account that never got as far as a space — nothing in it but the login — after ninety days. Removal takes the server's copy, the devices and any published pages; the notes on your own devices stay where they are. Signing in once resets the clock. Nothing is removed automatically: the operator looks at the list and deletes by hand, so an account is never taken away on the day the rule is met.

Spaces made by old versions without a password are not silently rewritten or encrypted: converting them could damage data that already exists.

If local storage fails, Juie closes rather than pretends: it blocks changes and sync and shows read-only plainly, instead of acting as if new data were saved.

A PIN locks the already-open app after one, two, five or thirty minutes without activity in Juie. Switching to another app does not lock it by itself — come back quickly and you carry on; come back later and Juie asks for the PIN. It guards the interface, not the space, and turning it off needs the current code.

Sync

Sync is between your devices; the server is a relay that cannot read anything. What goes over the wire is compressed before it is encrypted, so a note travels several times smaller than its raw editing history.

Reconnecting does not re-upload a document whose exact state the server has already confirmed, and Juie compacts the history of notes you have not opened in small background passes. None of this needs a setting or any cleanup by you. Both sides have to be up to date: with an older server, or when delivery is uncertain, Juie resends rather than risk assuming.

Sync being green means the server has your changes. If it turns red, hover it — it says whether the server is unreachable, refused the connection, or refused to store something.

Updates

Settings → Updates shows the version you have and checks for a newer one when you ask — never on its own, because the check tells juie.net your address. If there is one, a second button installs it: an installed app updates and restarts, the portable build replaces its own juie.exe and restarts, and on Android the system installer opens with the new APK for you to confirm. Every download is checked against a signature baked into the app before anything is replaced. The web version has nothing to update.

Where the data is

In a browser it is in IndexedDB, tied to that browser profile and that address. The in-app browser, an external browser and the native app therefore see different local databases until sync is set up or a snapshot is carried over. Desktop and Android use the native app's storage.

Everything saves by itself. List metadata updates after a short pause in typing, so the interface is not redrawn on every letter.

Updating and reinstalling on Windows

The program and your data live apart: the app is in %LOCALAPPDATA%\Juie, the database in the %LOCALAPPDATA%\app.juie.desktop profile. An ordinary update therefore needs no export and import.

Each Windows release has two files:

Close Juie before updating. Even with program and data separated, make a manual .juie copy before an important update — against a disk failure, a mis-click, or the device itself. In the normal case you will not need it. For a locked space, keep the recovery phrase, or another device's key file, somewhere separate.

Run the Windows installer by double-clicking it in Explorer. Started from an assistant's sandbox it can end up in a virtualised profile, where the app shows a different local database although nothing has been deleted.

Portable Windows build

juie.exe from a release needs no installer and touches nothing outside its own folder — no registry, no %LOCALAPPDATA%. On first start it creates Juie Data beside itself and keeps everything there: the database, the key envelopes, the search index, the browser engine's profile, and its own snapshots. Copy the folder to a flash drive and it opens on another computer with your password; keys are wrapped by the password, not tied to a machine.

Updating is replacing juie.exe. Two versions can sit beside one data folder, but data written by a newer version refuses to open in an older one — it says so instead of quietly working on top of it.

A flash drive can be pulled mid-write, and the browser engine's database is not built for that; when it finds a damaged store it may discard it. So the portable build writes an encrypted snapshot into Juie Data/Backups after every pause in your work and keeps the three newest. If the base ever fails to open, start juie.exe and choose "Connect an existing vault" with the newest .juiex — the snapshot carries its own keys and opens with the same password; nothing from the old machine is needed. With a Juie account no snapshots are written, because the server already holds the copy.

The one thing a portable build cannot bring along is WebView2, the Windows browser engine. It ships with Windows 10 and 11; on a machine without it, Juie shows a link to Microsoft's installer, and that is installed once for the machine. Windows itself still keeps its usual traces of a program having run — recent files, prefetch — which no application can prevent.

Platforms, and what this version does not do

Juie is built for macOS, Android and Windows from one Tauri project, and runs in a browser at app.juie.net. On macOS the empty part of the title bar drags the window, and a double click zooms it without going fullscreen.

Open registration on the public server is not switched on yet. Drawing on a canvas, attachments, image storage, plugins and several people editing one note together are not planned.

This guide is part of the product. When behaviour changes, it changes with the code and the patch notes. It is also available in Kazakh and Russian.