node.you Logo Image node.you

The node.you client: one portable C++ app built on Vortex that runs natively on desktop, web, and Android from a single codebase. The web build is node.you in the browser: the app is served from the node.you domain and runs entirely client-side.

✨ This project is developed with AI-assistance. Please refer to our AI policy.

The platform

node.you is a social platform built on cryptographic identity. A node is an Ed25519 keypair reachable at <name>.node.you. Users verify each other by exchanging node codes (QR or link), and that verification gates every interaction: who can comment, who can vote, and who gets to see a commenter's real identity. Profiles are independent services (one isolated instance per user) that interoperate through public signature checks, so there is no central social graph and the whole stack is self-hostable.

This app is the client for that platform. It talks to two APIs:

  • The coordinator (nodeyou-api) at node.you/api: accounts, nodes, relations, signing, and billing.
  • Each profile service (ny-profile-api) at <subdomain>.node.you: profiles, posts, comments, votes, feeds, and uploads.

Features

  • Accounts: email sign-in and account creation, persistent sessions with automatic token refresh, in-app account deletion.
  • Nodes: create nodes with live subdomain availability checks. Host custody (the coordinator signs for you) or self custody: the keypair is generated on-device, sealed in a passphrase envelope, and stored only in encrypted form, with mandatory backup (QR, copy, or save-to-file), unlock, and import flows.
  • Profiles: launch a profile service on a node; edit your display name, bio, and picture.
  • Posts: Markdown bodies, image and video attachments, link cards, public or private visibility.
  • Comments: threaded and anonymized by default; identities are revealed only to viewers the commenter has verified.
  • Votes: up and down votes on posts and comments, gated to verified contacts.
  • Contacts: verify and follow other nodes, add contacts by name or URL with live lookup, and scan node codes with the camera on mobile.
  • Feed: an aggregated timeline of your own profile plus everyone you follow.
  • Billing: Stripe checkout and billing portal on desktop and web, Google Play billing on Android, with cross-provider routing when a subscription is managed on the other rail.
  • Theming: runtime dark/light and accent themes with per-app persistence and user theme directories, inherited from the framework shell.
  • Self-hosting: point the client at your own coordinator from the sign-in screen.

How it's built

The interface is declared in Layers JSON (styles/): node.you's App root style and its panes load additively on top of the framework's widget library, and the app inherits Vortex's Main Window shell (titlebar tabs, settings menu, theme dialogs) whole. app/ supplies the portable core:

Piece Responsibility
nodeyou_app.cpp build_app(): applies the root style and wires every screen, drawer, and dialog
nodeyou_client Coordinator API client: auth and refresh, accounts, nodes, relations, signing, billing
profile_client Profile service client: per-profile sessions, feeds, posts, uploads, votes, comments, identity resolution
feed_aggregator Merges your profile and followed profiles into one feed, with per-source caching and delta refresh
nodeyou_crypto Portable self-custody crypto (vendored Monocypher + Mbed TLS): Ed25519 keys, passphrase envelopes, challenge signing

All I/O crosses the framework's injected platform seams (HTTP, persistence, timers, file pick, purchases), so app code is identical on all three targets; each platform shell is a few lines handing identity and asset directories to the framework runner. Keys and signatures only ever cross the core↔platform boundary as base64 strings.

Repository layout

app/        Portable C++ app core: build_app() plus the API clients and crypto.
styles/     node.you's styles (Layers JSON), loaded additively over the framework library.
icons/      App SVG icons.
platforms/  Thin shells: desktop/ (Qt6), web/ (WASM host page), android/ (Gradle app).
plans/      Design plans, written as each feature was built.
ext/        The Vortex framework (submodule) + vendored Monocypher and Mbed TLS.

The build resolves the framework via VORTEX_ROOT: the ext/vortex submodule when present, falling back to the sibling checkout ../../vortex/vortex in the dev workspace.

Build & run: desktop

Requires CMake 3.22+, a C++17 compiler, and Qt6 (Core/Gui/Widgets/Svg).

git clone --recursive https://codeberg.org/HuntrSoftware/nodeyou.git
cd nodeyou
cmake -B build -DCMAKE_BUILD_TYPE=Debug
cmake --build build -j
./build/platforms/desktop/nodeyou-desktop

Headless screenshot (no display needed):

QT_QPA_PLATFORM=offscreen VORTEX_SHOT=/tmp/nodeyou.png \
  ./build/platforms/desktop/nodeyou-desktop

The self-custody crypto self-test:

cmake --build build --target crypto_selftest && ./build/platforms/desktop/crypto_selftest

Build & run: web

Requires the Emscripten SDK (emcc). The framework's web reconciler renders the app into the DOM; the library styles/themes and node.you's App styles are baked into the WASM, so the build force-relinks vortex.js/vortex.wasm to pick up style edits. Output lands in platforms/web/.

source /path/to/emsdk/emsdk_env.sh
emcmake cmake -B build-web -DCMAKE_BUILD_TYPE=Release
cmake --build build-web -j

# serve the page (WASM needs http, not file://)
python3 -m http.server 8098 --directory platforms/web
# then open http://localhost:8098/

Build & run: Android

Classic Views (no Compose). Requires the Android SDK + NDK 29 and a JDK. The Gradle build pulls the framework's :vortex library module from the submodule and compiles libvortex_bridge.so from the framework C++ plus node.you's build_app(). Debug builds carry a .debug applicationId suffix so they install alongside the published com.huntrsoftware.nodeyou.

cd platforms/android
export ANDROID_HOME=$HOME/Android/Sdk
./gradlew :app:assembleDebug

adb install -r app/build/outputs/apk/debug/app-debug.apk
adb shell am start -n com.huntrsoftware.nodeyou.debug/com.huntrsoftware.nodeyou.MainActivity

Build everything

./build-all.sh builds desktop, web, and Android in one pass and prints a pass/fail summary (it initializes the ext/vortex submodule if empty and probes for emsdk and a JDK).

Documentation

Documentation and user guides live at huntrsoftware.com/nodeyou. The design plans in this repository capture the architectural decisions behind each feature as it was built.

Appearance
Theme
—