A highly secure, privacy-first, self-hosted notes platform.

Neurite is built with a singular philosophy: Privacy isn't about having something to hide — it's about having something to protect. It features robust Server-Side Encryption (SSE), local/NAS/S3 storage management, multi-device sync with conflict resolution, and an uncompromising focus on usability across desktop and mobile.

🚀 Tech Stack

• Frontend: React, Vite, TypeScript (Strict Material 3 "Vivid Slate" Design System, Vanilla CSS)
• Backend: C# .NET 8 ASP.NET Core (Clean Architecture)
• Database: PostgreSQL 16
• Security: Server-Side Encryption (AES-256-GCM), Argon2id, audit trail, mount isolation, strict Git leak prevention.

🚀 Quickstart

Option 1: Automated Installation (Recommended)

The recommended way to deploy Neurite for production is via the automated installation script.

How it works:

1. Lightweight Footprint: The script securely fetches only the minimal necessary orchestration files (e.g., docker-compose.yml) and automatically generates your secure .env secrets. It does not clone the full source code repository onto your production server.
2. Pre-built Images: It pulls the latest pre-built production Docker images from the Forgejo registry for near-instant deployment.
3. Interactive Fallback: If you are running on an unsupported CPU architecture or the registry is unreachable, the script will gracefully pause and provide an interactive TUI prompt asking if you'd like to download the full repository and build the Docker images locally from source.

curl -fsSL https://forge.sabylasolutions.com/sabyla/Neurite/raw/branch/main/release/install-neurite.sh | bash

Option 2: Manual Clone & Setup (Development/Alternative)

1. Clone the repository:

   git clone https://forge.sabylasolutions.com/sabyla/Neurite.git
   cd Neurite
   

2. Spin up the infrastructure: This single command will spin up the PostgreSQL database (on an isolated named volume), the .NET API backend, and the Vite React frontend.

   docker compose up -d
   

After Installation:

1. Open your browser and navigate to http://<your-server-ip>:3344 (or http://localhost:3344 for local setups).
2. Follow the First-Run Setup Wizard to configure your initial admin account.
3. Download the Android app and connect it to your server via the app's setup wizard.

Uninstallation (Danger)

To completely remove Neurite and irreversibly destroy all of its associated data (database, encrypted mounts, and secrets), you can run the uninstall script from within your installation directory:

cd neurite
./release/uninstall-neurite.sh

Or, if you installed via the automated script and want to curl the uninstaller:

curl -fsSL https://forge.sabylasolutions.com/sabyla/Neurite/raw/branch/main/release/uninstall-neurite.sh | bash

📱 Android Offline App

The Android companion application works perfectly without a network connection. When you run the initial setup wizard, just tap "Local Storage Only". That turns Neurite into a fully self-contained note app sitting quietly on your phone. You don't need a server to start. If you eventually spin up a self-hosted backend, the app safely synchronizes everything you've written.

We recently rebuilt the sync engine. It now uses a one-second debounce, which means you can delete, type, and rewrite without the auto-save stuttering or fighting your keyboard. You can also flip between light and dark modes, or toggle between flat and card-style editor layouts to fit your preferences.

🛠 Local Development Environment

To ensure strict separation of development and production data, the local development environment relies entirely on Docker Named Volumes.

Prerequisites

• Docker & Docker Compose
• Node.js (for local frontend tooling)

Accessing the Local Environment

• Web Frontend (Hot-Reloading): http://localhost:3344
• Backend API (Hot-Reloading): http://localhost:5000
• Database: localhost:5432
• BookStack Wiki: http://localhost:3001

Running Backend Commands

The .NET SDK runs inside the neurite-backend container. Use docker compose exec or docker exec to run CLI commands:

# Run EF Core migrations
docker compose exec backend dotnet ef migrations add MigrationName

# Run tests
docker compose exec backend dotnet test Notes.Tests

# Open a shell
docker compose exec backend bash

🛠 Troubleshooting

Database Password Mismatch

The Issue: When a PostgreSQL container runs for the first time, it initializes the database and sets the user credentials using the environment variables (POSTGRES_USER and POSTGRES_PASSWORD). Once the data volume (pgdata) is created, PostgreSQL never updates the user password from environment variables on subsequent restarts. If the .env or docker-compose password is changed later, the backend reads the new password, but the database expects the old one, leading to authentication errors (28P01: password authentication failed).

(Note: The automated installation script now natively protects against this. If you run the installer and choose to overwrite an existing installation directory, it will automatically tear down the orphaned Docker volumes using docker compose down -v before generating new secrets, ensuring a completely clean slate).

How to fix manually:

Option A (Preserves data): Alter the password inside the running database manually:

docker exec -u postgres neurite-db psql -U neurite_user -d neurite_dev -c "ALTER USER neurite_user WITH PASSWORD 'new_password_here';"

Option B (Re-initializes DB - warning: deletes data): Recreate the container and volume from scratch to let Postgres initialize with the new password:

docker compose down -v
docker compose up -d