# P3X OneNote Linux: isolated account tabs and a tray-resident window

> P3X OneNote Linux puts the online OneNote inside its own Electron process, with one isolated session per account tab. It is a window shell around a remote page, not a local notebook implementation.

**patrikx3/onenote** — 📚 Linux Electron Onenote - A Linux compatible version of OneNote

- Repository: https://github.com/patrikx3/onenote
- Website: https://www.corifeus.com/onenote/
- Stars: 2,078 · Forks: 112
- Language: JavaScript
- License: MIT
- Published: 2026-10-13 · Updated: 2026-10-13 · Language: en
- Canonical page: https://hysenlabs.com/projects/patrikx3-onenote

## A window for the online OneNote, not a local notebook

There is no local OneNote client in this repository. What patrikx3/onenote provides is the other route: the online OneNote, wrapped so that it runs in an Electron process of its own instead of borrowing a browser tab. The README calls it an independent browser window for the online OneNote, and that single decision explains nearly everything else about the project. Every feature it ships is a layer over a remote page, so nothing in the repository describes reading or writing notebook files, and the settings backup it offers covers tabs, bookmarks and preferences, which is the only local state anywhere in the picture. That sets the ceiling on what the app can do. It can hand the page its own window, its own session per account and its own lifecycle. It cannot add editing features that Microsoft does not serve to the web client.

The audience is narrow and obvious. Someone on Linux who keeps OneNote open all day, who signs in with more than one Microsoft account, or who wants the web app out of the way of real browsing gets real value from it. Accounts can be corporate or personal. The app can also open other Microsoft online applications, with OneNote as the dedicated purpose, and its topic tags, from electron and nodejs through office, onenote and tray, say exactly where it positions itself.

## One isolated Electron session per account tab

Multiple account tabs are the part a plain browser tab cannot match. Each tab holds its own isolated session, so two Microsoft accounts stay signed in at the same time without one overwriting the other's cookies. After login the label switches to the account email, and the right-click menu on any tab offers rename, clear custom name, pin, unpin, duplicate and close. A custom label such as Work or Personal replaces the account type and email, and a pinned tab refuses to close. Duplicate creates another tab with the same URL and account type, and tabs drag left and right with an order that persists across restarts. Every tab keeps its own zoom level. The `Action > Restore last closed tab` returns a closed session with its login intact, up to 10 entries in history. That menu table ends mid-row, on the close option, so the confirmation wording for a non-pinned tab is left undefined, and nothing says whether an unpinned tab survives a restart.

## Tray residency, single instance and a cached session

Three behaviours keep the window out of the way. Close to tray is a checkbox in the settings menu: checked, a quit minimizes to the tray instead of exiting; unchecked, it closes the process completely. Launch minimized has its own command line argument, `--minimized`. Starting the app a second time does not open a second copy, because a single instance rule brings the existing window forward. Startup speed is claimed to come from cached data in place of opening a new browser tab each time, and no measurement sits next to that claim, so read it as design intent rather than a number. Auto-updates arrive without asking, and with desktop notifications enabled an update, a bookmark or an offline status change fires a native toast that pulls the window forward when clicked. Unplugging a monitor is covered too: when the window would land off-screen, it centers itself on the primary display.

## The package scripts are the documented way to run it

The README prints no end-user install line, so packaged builds are the route it points at, through the `corifeus` homepage in AppImage, deb and rpm form alongside `Snap/Flatpak`. For the source tree, the documented entry points are the scripts in package.json, and the first one deserves attention. The run script starts Electron with the sandbox switched off for the whole application, which is convenient in development and a poor default for a wrapper that holds signed-in Microsoft cookies.

```json
"run": "electron --no-sandbox .",
"start": "node ./node_modules/.bin/electron ./src/electron/app.mjs",
"main": "src/electron/app.mjs",
"bin": {
    "p3x-onenote": "bin/p3x-onenote.js"
}
```

Both start lines reach the same entry point, `src/electron/app.mjs`, one passing the directory so Electron reads the main field, the other calling the local binary with the file path. The bin entry installs a `p3x-onenote` executable resolving to `bin/p3x-onenote.js`, and `yarn.lock` pins dependencies at the root.

```json
"test": "vitest run",
"test:watch": "vitest",
"test:grunt": "grunt",
"dist": "electron-builder",
"build": "electron-builder --x64  build/dist"
```

Test tooling is split in two: `vitest.config.mjs` drives vitest run, while `test:grunt` still reaches for a `Gruntfile.js`. Packaging runs through electron-builder, with build pinning x64 output and a separate build-test script set to always rebuild. The tree sits ahead of its own build record: the README banner and package.json both read 2026.4.150, the newest build in that record is v2026.4.132 dated 2026-04-06, and the last push was on 2026-06-06, leaving two months with no matching build.

## Autostart is the one feature packaging quietly removes

Auto-launch on login is what packaging removes in places. The setting starts the app minimized to the system tray, and the README scopes it precisely: AppImage, deb and rpm builds have it, `Snap/Flatpak` builds do not, because the OS manages autostart there. That boundary concerns packages rather than code, so one person on two distributions gets two different settings menus. A second packaging detail deserves reading before anything gets installed. The corifeus block of package.json carries an install step for AppImage users that reaches for root on the host system:

```json
"install-appimage-launcher": "sudo add-apt-repository ppa:appimagelauncher-team/stable && sudo apt install -y appimagelauncher"
```

Sitting beside it are flags such as snap set to true, code set to Linux and a p3x- prefix applied to names. Following that line adds a third-party apt repository on Ubuntu-family machines, a privileged change made on behalf of a user interface shell. Flatpak publishing carries three scripts, one per architecture, and each pins freedesktop runtimes rather than tracking the distribution:

```json
"publish-electron-test-flatpak-info": "flatpak install flathub org.freedesktop.Platform//20.08 && flatpak install flathub org.freedesktop.Sdk//20.08 && flatpak install flathub org.electronjs.Electron2.BaseApp//20.08"
```

The aarch64 variant points at the same 20.08 runtimes, while an arm variant asks for 18.08.

## Dark mode and language stop at the app chrome

Two presentation features are openly shallow. Dark mode is labelled a non-official workaround that may show minor inconsistencies, because Microsoft does not support it directly, and `Settings > Dark mode > Follow system` ties it to the operating system theme when you want it to track. The language selector is narrower again: it controls the Electron interface, the menus, dialogs and buttons, and nothing about the OneNote page, which follows the language set in the Microsoft account profile. 30 community translations ship in `src/translation`, running from Afrikaans to Simplified Chinese, and not one of them touches notebook content.

A third boundary sits in the same menu, and it is the awkward one. A `Corporate home` item exists, and the README states that debugging it is not possible without a corporate login, and that supplying login details may help when problems appear. Any team weighing this app on a managed workstation has to decide what it is willing to hand over before opening an issue.

## Where the wrapper stops short of a OneNote client

Three limits decide whether this is the right tool. The first is offline work. There is no local copy to fall back on: the app detects network loss, shows a You are offline notification, and reloads every tab once connectivity returns, debounced so a flaky link does not loop. That is reconnect behaviour rather than offline editing, and an edit begun on a train still depends on the page's own save path. The second is where sessions live. This wrapper keeps Microsoft sign-ins in its own Chromium profile instead of a browser profile, which is also why it carries a granular cleaner: `Clear data and restart` wipes cookies, cache or everything, for all tabs or just the current one. The third is scope. Because other Microsoft online applications can be opened too, this behaves as a general shell with OneNote as the default, which stays convenient until you need a per-application firewall rule.

## What a browser tab already does for free

The real alternative is the same web app in a browser window, and the difference is not rendering. A browser hands you one cookie jar per profile, so a second Microsoft account means a second profile and a second window to manage. This app gives each account an isolated session inside one window, with a tab bar, drag reordering, per-tab zoom and tray residency, which is the whole argument, and it holds for as long as you want the page detached from your browsing. Against it, an Electron shell carries its own runtime instead of sharing the system browser, and AppImage users are asked to add a privileged apt repository first. Two claims also sit unmeasured: the faster startup from cached data, and recovery of a closed tab with its login intact, where history stops at 10 entries. Where this loses to a browser is everywhere the browser has already built, profile handling and session juggling among them, plus anything Microsoft changes in the page underneath it.

## Conclusion

Adopt P3X OneNote Linux if you run Linux, keep the online OneNote open all day, and want two Microsoft accounts side by side or the page out of your browser. Tab isolation, tray residency and per-tab zoom are real, and the scripts in package.json make a source build quick. Pass if you need local notebook files, offline editing, or a shell that survives Microsoft rewriting the page underneath it. Check the `--no-sandbox` run script and the corporate login request before putting it on a managed workstation.

## FAQ

### What is P3X OneNote Linux, and what does it actually wrap?

It is an Electron application that shows the online OneNote in its own Linux window instead of a browser tab. Everything it adds is a layer over that remote page, and the repository describes no local notebook file support.

### Can I sign into two Microsoft accounts at once in P3X OneNote Linux?

Yes. Each account tab keeps an isolated session, tab labels show the account email after login, and up to 10 closed tabs can be restored with the same login session.

### Which P3X OneNote Linux packages can start at login?

Auto-launch on login is offered on AppImage, deb and rpm builds. The option is hidden on Snap and Flatpak, where the operating system manages autostart.

### Does P3X OneNote Linux work offline?

No offline editing is described. It detects network loss, shows an offline notification, and reloads all tabs when connectivity returns, debounced to avoid reload spam.

### Can I change the language of my notebooks in P3X OneNote Linux?

Not through the app. The language selector only covers the Electron interface, menus, dialogs and buttons, while the OneNote page language comes from the Microsoft account profile.

### What licence is P3X OneNote Linux released under?

MIT. A LICENSE file sits at the top level of the repository, and the package manifest carries the same identifier.

## Sources

- [License: MIT](https://github.com/patrikx3/onenote/blob/main/LICENSE)
- [patrikx3/onenote on GitHub](https://github.com/patrikx3/onenote)
- [Project website](https://www.corifeus.com/onenote/)
- [README](https://github.com/patrikx3/onenote/blob/main/README.md)
- [Releases](https://github.com/patrikx3/onenote/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/patrikx3-onenote