Notes as Markdown files in the browser, with a graph you can zoom into. Self-hosted.
2.4K
Notes as Markdown files, edited in the browser, with a graph you can zoom into. Self-hosted, for yourself or a small team, and friendly to Obsidian: the files on disk stay the truth, and Obsidian, Syncthing or any editor may work on the same folder at the same time.
nexlore is one of the nex apps and looks like them: turquoise, dark and light.

The graph. Folders are bubbles; zoom in and they open to show their notes and the links between them. It is drawn with WebGL and stays smooth with 100,000 notes. Folders, tags or topics found in the text, at the switch on top.

Reading: properties, callouts, tables, tasks, highlights and parts of other notes embedded, the way Obsidian shows them. Recent notes and favorites on top of the sidebar; on the right the backlinks and every link of the note, next to the outline, comments, the local graph and the versions.

Editing: a visual editor with a toolbar like a word processor's, the front matter as a table of properties, and /
to insert. Only the blocks you touch are written back; the rest of the file stays byte for byte as it was.

Tasks from every note in the format of the Obsidian Tasks plugin, by due date or by note. Ticking one off writes that one line and nothing else. Next to it: a calendar with the daily notes, and a daily note one key away.
Light and dark, two notes side by side, and on the phone as an installable web app. Spaces for a team, with links from one space into another that only resolve for people who may read both.
/ to insert, Markdown shortcuts, a grip to drag blocks, a context menu, properties from
the front matter as a table. Only the blocks you touched are written back; every other line stays byte for byte as
it was, line endings included.[[Note]], [[Note#Heading|shown]], embeds ![[picture.png|300]]
and of notes or their parts (![[Note#Heading]], ![[Note#^block]], one level deep), callouts (folding with
- and +), highlights, comments %%…%%, tags, front matter, tasks in the format of the Tasks plugin. Plugin syntax
(Dataview, Templater, Excalidraw) is shown as code and never touched. .obsidian/ is left alone..canvas, as Obsidian writes them): lay notes, text, pictures and
links on a surface without edges, group them and join them with arrows. Notes show on their cards and open beside
the canvas for editing, text cards are edited in place with the same editor, cards snap to each other while you
move them. A canvas is saved like a note (one person at a time, a conflict copy instead of overwriting, versions),
renaming a note rewrites its path on every canvas, and a change rewrites only the lines of the cards it touched.{{date}}, {{title}} and friends), a task overview
across all spaces (due, scheduled, recurring, done), installable on a phone as an app.Attachments folder, pasted pictures named after the note. The operator
picks the folder name (the folders already there follow, links and all) and name patterns for pasted pictures and
uploaded files ({note}, {filename}, {date}, {time}, {n}, with / for a folder per note); a space can hide
its attachment folders from the sidebar. Place and
device are removed from photos and videos on upload (on by default), HEIC gets a WebP copy, duplicates are found
by content, PDFs are searched. SVG and HTML are always downloaded, never run.![[Manual.pdf#page=3&height=400]] embeds a reader in a note,
[[Manual.pdf#page=3]] opens that page, and a PDF opens beside a note to read and write at the same time. The
file's page lists the notes that link the PDF, with their pages.[[Team/Note]]) and resolve only for whoever may read it. What
somebody may not read does not show up anywhere, not in search, graph, backlinks or tasks, not even its title.common or organizations as the issuer).
An identity at a provider belongs to an account only once that account linked itself in its profile, came in by
invitation, or the operator lets new people in through that provider; an account is never found by its mail
address. Per provider the operator decides whether it checks the second factor itself. Invitations by link or by
mail. Every account has a mail address: entered in the profile it counts once the link mailed to it is opened, the
operator can set one at once, and an account through a provider only follows the provider's.services:
nexlore:
image: ghcr.io/derkezorm/nexlore:latest
container_name: nexlore
restart: unless-stopped
ports:
- "8470:8000"
volumes:
- ./data:/data
environment:
PUID: 1000
PGID: 1000
TZ: Europe/Berlin
docker compose up -d
Built from source instead: clone this repository, put build: . in place of image: and run
docker compose up -d --build.
Open http://<your-host>:8470. The first account you create there is the operator. It needs the setup code
from the server's log, so that nobody who reaches a fresh instance first can take it:
docker logs nexlore
shows a line The setup code is 3F9A-0C21-B7E4, new at every start until nexlore is set up. To choose it yourself,
set NEXLORE_SETUP_TOKEN. docker-compose.yml in this repository has the same service with every option explained.
Put nexlore behind a reverse proxy with TLS before you use it from anywhere but your own desk. Installing it on a phone also needs HTTPS; browsers offer it only on secure origins.
nexlore is made to be reachable from outside, for yourself on the road or for a small team. Before you open it:
127.0.0.1:8470:8000
when the proxy runs on the same host, or keep both on a Docker network without a published port. Send HSTS from
the proxy.NEXLORE_PUBLIC_URL (the address people use), NEXLORE_TRUSTED_PROXIES (the
proxy's address or network; without it every sign-in seems to come from the proxy and the brake against guessing
cannot tell people apart; the log says so; only such a proxy is believed about X-Forwarded-For and
X-Forwarded-Proto, so that the return address of a sign-in is https; the warning in the authentik card under
Settings, Sign-in points here, and the session cookie gets its Secure flag from it), and
NEXLORE_COOKIE_SECURE: "on".NEXLORE_OPERATOR_NETWORKS: "192.168.0.0/16" refuses them
from anywhere else (behind a proxy only together with NEXLORE_TRUSTED_PROXIES).secret.key included. Copy one off
the machine now and then, as carefully as the data directory, and try a restore with "Check".ghcr.io/derkezorm/nexlore:1.0) instead of latest, update on purpose, back up before.docker-compose.yml (read_only, cap_drop,
no-new-privileges, a memory limit, log rotation) work with nexlore.Whatever is in nexlore leaves only where you open a way: the webhooks and mail of each account, the AI service an account enters (public addresses, or hosts in your own network you list), the daily update check against GitHub (off on the About page), and connectors you sign in.
By default the notes live in data/vault. To keep them elsewhere, for example in a folder that Obsidian or
Syncthing also works on, mount it and point nexlore at it:
volumes:
- ./data:/data
- /srv/notes:/vault
environment:
NEXLORE_VAULT_DIR: /vault
The container adjusts the owner of /data to PUID/PGID on every start, but not of a vault mounted elsewhere:
that folder must already be writable for the user PUID/PGID.
Every folder at the top of the vault is a space. A space without members belongs to the operator; invite people into it under Settings.
Some network shares and container mounts deliver no change notifications. Set NEXLORE_WATCH_POLLING: "true"
there, or rely on the full pass every five minutes.
Everything else lives in /data: the SQLite database nexlore.db (index, versions, trash, accounts), secret.key,
backups/, logs/, trash/, locales/. Mount it from a local disk, never from an SMB or NFS share: SQLite's
locking does not work reliably over network filesystems.
The database can always be rebuilt from the files, except for versions and the trash. Back it up with nexlore's own backups (Settings, Backups), which copy it consistently while it runs, never by copying the file.
secret.key protects what the server must read on its own (the OIDC client secret, the mail password, the seeds of
second factors). It goes into every backup. A different key means second factors can no longer be checked; the
operator resets them.
A backup archive is a plain ZIP: the database, every note and file, and secret.key. Whoever has it has everything,
so keep downloaded copies as carefully as the data directory itself.
Moving to a new server: download a backup, set up nexlore there, upload the backup under Settings, Server, Backups, check it and restore it. Afterwards the new server has the old accounts, spaces, notes and files.
With an image: docker compose pull && docker compose up -d. Built from source: pull the new code and run
docker compose up -d --build. nexlore adds what the database lacks at the start and backs the database up first;
nothing needs doing by hand. Make a backup before a big jump anyway (Settings, Backups).
| Variable | Default | Meaning |
|---|---|---|
NEXLORE_DATA_DIR | /data | Database, logs, backups, trash, languages |
NEXLORE_VAULT_DIR | <data>/vault | The notes, as Markdown files |
NEXLORE_LOCALES_DIR | <data>/locales | Extra languages, one JSON file each |
NEXLORE_SECRET_KEY | created on first start | Protects server-side secrets; when set, it wins over secret.key |
NEXLORE_PUBLIC_URL | from the request | The address people use to reach nexlore, for invitation links, the links confirming a mail address, public pages and the OIDC redirect. The setting under Settings, Sign-in wins when set |
NEXLORE_TRUSTED_PROXIES | none | Addresses or networks of reverse proxies whose X-Forwarded-For and X-Forwarded-Proto are believed (of X-Forwarded-Proto the rightmost value, the one the proxy appended), comma separated. Without it every request counts as coming from its peer, and as http if that is how it arrives, so the session cookie has no Secure flag unless NEXLORE_COOKIE_SECURE is on |
NEXLORE_SETUP_TOKEN | made at start | The code the first account needs; without it nexlore makes one at every start until set up and writes it to the log |
NEXLORE_OPERATOR_NETWORKS | none | Networks the operator's settings may be changed from, comma separated (192.168.0.0/16); everything else stays reachable from anywhere |
NEXLORE_WATCH_POLLING | false | Watch the vault by polling, for mounts without change notifications |
NEXLORE_SCAN_INTERVAL | 300 | Seconds between two full passes over the vault; 0 turns them off |
NEXLORE_SESSION_DAYS | 30 | A browser session ends after this many days |
NEXLORE_LOG_LEVEL | stored setting | quiet, normal, detailed or trace; overrides the setting, the way out when the app does not start |
NEXLORE_COOKIE_SECURE | auto | on, off or auto (Secure when the request came over HTTPS, or a proxy in NEXLORE_TRUSTED_PROXIES says so through X-Forwarded-Proto; behind any other TLS proxy set on) |
NEXLORE_API_DOCS | false | Serves /api/docs and /api/openapi.json |
NEXLORE_PORT | 8000 | Port inside the container, for host networking |
PUID, PGID | 1000 | Owner of the files in the data directory |
nexlore reads a vault the way Obsidian does: a link finds the note of that name in the same folder first, then the
one with the shortest path; [[Folder/Note]] and relative Markdown links are read as paths. A link with the name
of another space in front ([[Team/Note]]) leads into that space; the own space always answers first, so a folder
called Team in your space wins over the space Team.
What nexlore writes stays readable for Obsidian: links in the style they had, file names that are safe on Windows,
macOS and Linux (a title with other characters goes into the front matter as title:), conflict copies named
Note (conflict 2026-09-28 101500).md. Tasks are counted outside code blocks and %%comments%% only.
X-Nexlore-Client, which a page on another site cannot send.cd backend && python -m venv .venv && .venv/Scripts/python -m pip install -r requirements-dev.txt
.venv/Scripts/python -m uvicorn app.main:app --port 8470
cd frontend && npm ci && npx vite
On Linux the virtual environment's programs are in .venv/bin. The frontend on port 5470 sends /api to the
backend. Tests: python -m pytest -q in backend; npx vitest run, npm run test:browser (the editor in a real
browser) and npm run e2e (builds, starts its own backend, runs headless) in frontend.
AGPL-3.0.
The symbols for spaces and folders include the Lucide icons (ISC, partly MIT from Feather);
their notice is in frontend/public/licenses/lucide.txt and ships with the app at /licenses/lucide.txt.
Everything else nexlore ships or depends on, with its licence, is listed in THIRD-PARTY.md.
Content type
Image
Digest
sha256:a2f8b7df1…
Size
153.1 MB
Last updated
1 day ago
docker pull derkezorm/nexlore