Nyora ships as a family of native apps that share one open-source parsing engine. Every platform lives in its own repository under the Hasan72341 account, and each one builds from source with standard tooling — no private SDKs, no hidden steps. This guide gives you the exact clone, prerequisite, build and packaging commands for each target.

Just want to run Nyora? You don't need to build it. Grab a prebuilt installer from the Download page, or read in your browser at nyoraweb.pages.dev. This page is for people who want to compile it themselves or contribute.

Repositories at a glance

Pick the repo for the platform you want to build. The three desktop ports (Windows, macOS, Linux) share the nyora-shared parsing engine as a Git submodule — clone those recursively. Android, iOS and Web are self-contained with no submodules.

Repository	Target	Tech	Submodule	License
`nyora-android`	Android	Kotlin, Jetpack Compose	No	GPLv3
`nyora-windows`	Windows desktop	Compose Multiplatform, jpackage	Yes	Apache-2.0
`nyora-mac`	macOS	SwiftUI + Kotlin engine	Yes	Apache-2.0
`nyora-linux`	Linux desktop	Compose Multiplatform, jpackage	Yes	Apache-2.0
`nyora-ios`	iOS / iPadOS	Swift, SwiftUI	No	Apache-2.0
`nyora-web`	Browser PWA	TypeScript / ES modules	No	Apache-2.0

Cloning (read this first)

The Windows, macOS and Linux desktop ports consume the parsing engine through a Git submodule at nyora-shared/. If you forget to fetch submodules the build will fail with missing engine sources, so clone with --recurse-submodules:

# desktop ports bundle the shared engine as a submodule
git clone --recurse-submodules https://github.com/Hasan72341/nyora-linux.git
# (works the same for nyora-windows and nyora-mac)

Already cloned without submodules? Initialise them after the fact:

git submodule update --init --recursive

Android, iOS and Web have no submodules — a plain git clone is all you need:

git clone https://github.com/Hasan72341/nyora-android.git
# (or nyora-ios / nyora-web)

Prerequisites

Install the toolchain for the target you're building before you start.

Target	You need
Android	Android Studio (Ladybug+), JDK 17
Windows	JDK 17+, WiX Toolset v3 on `PATH`
macOS	JDK 17+, Xcode / Swift toolchain (Apple Silicon Mac)
Linux	JDK 17+
iOS / iPadOS	Xcode, Swift toolchain
Web	Node.js + esbuild (production build only; dev needs no build)

The desktop ports bundle their own Java runtime into the final artifact, so your end users never install a JRE — JDK 17 is only required on the build machine.

Android

A native Kotlin / Jetpack Compose app targeting Android 6.0 (Marshmallow) and newer, on phones and tablets. Requires Android Studio (Ladybug+) and JDK 17.

Open the nyora-android folder in Android Studio and let Gradle sync.
For a quick debug install, use Run ▸ app to build and deploy to a connected device or emulator.
For a release build, run the Gradle task below.

# from nyora-android/
./gradlew assembleRelease
# the signed release APK lands under the app module's build outputs

The release task produces the universal app-release APK you can sideload — the same artifact published on the Releases page. If a build fails, run ./gradlew clean and restart Android Studio.

Windows

A Compose Multiplatform for Desktop app. jpackage produces a self-contained .exe installer with the Java runtime bundled in, so end users need nothing else. Requires JDK 17+ and WiX Toolset v3 on your PATH to produce the installer. x64 and ARM64 are built separately on their native runners (32-bit is not supported).

# from nyora-windows/
.\gradlew.bat :desktopApp:run                          # run locally for development

.\gradlew.bat :desktopApp:packageReleaseExe            # build the self-contained .exe installer
.\gradlew.bat :desktopApp:createReleaseDistributable   # build the app-image (input for MSIX)

The installer lands in desktopApp/build/compose/binaries/main-release/exe/. Because the nyora-shared engine is public, a full from-scratch installer build works for everyone — just make sure the submodule is present (see cloning) and WiX v3 is on PATH before packaging.

macOS

A native SwiftUI front end over the shared Kotlin engine, which runs as a bundled JVM helper. macOS is Apple Silicon only (M-series); Intel is not supported. The build script assembles Nyora.app around a bundled Adoptium Temurin 17 runtime and produces a .dmg — no Java install required by the end user.

# from nyora-mac/
./macApp/scripts/build-dmg.sh
# outputs nyora-mac/build/Nyora.dmg (Apple Silicon)

The first build downloads and caches the bundled JRE under nyora-mac/build/jre-cache/. The resulting app is ad-hoc signed (not notarised), so installing the .dmg manually triggers a one-time Gatekeeper prompt — see the Download page for the Homebrew install that skips it.

Linux

A Compose Multiplatform for Desktop app with a bundled JRE. Builds with JDK 17+ and packages for the build host's architecture (x86_64 or ARM64) via jpackage.

# from nyora-linux/
./gradlew :desktopApp:run                       # run locally for development

./gradlew :desktopApp:packageReleaseDeb          # .deb  — Debian / Ubuntu
./gradlew :desktopApp:packageReleaseRpm          # .rpm  — Fedora / RHEL
./gradlew :desktopApp:createReleaseDistributable # portable distributable (app image)

Each jpackage task emits an artifact for the architecture of the machine you build on — build on x86_64 for x86_64 packages and on ARM64 for ARM64 packages.

iOS & iPadOS

A native SwiftUI app in nyora-ios/NyoraApp targeting iOS / iPadOS 17+. Open NyoraApp.xcodeproj in Xcode and run on a simulator, or build an .ipa for a device from the command line.

# from nyora-ios/NyoraApp/
xcodebuild -scheme Nyora -sdk iphonesimulator -configuration Debug build   # simulator

# device build (sideload-ready; re-sign with your own Apple ID)
xcodebuild -scheme Nyora -sdk iphoneos -configuration Release \
  CODE_SIGNING_ALLOWED=NO build

The simulator build needs no signing setup, so it's the fastest path to a working app. To run on a physical device, set your development team and signing identity in Xcode and keep the bundle id com.nyora.ios so Nyora Sync works. Nyora is not on the App Store — device builds are distributed by sideload (AltStore / Sideloadly).

Web

The web app is authored as unbundled ES modules, so local development needs no build step — just serve the web/ directory with any static server:

# from nyora-web/ — local dev, no build needed
cd web && python3 -m http.server

For a production deploy, build.mjs bundles web/ into content-hashed, code-split chunks under dist/ (esbuild, ESM) — this is what ships to Cloudflare Pages at nyoraweb.pages.dev. It requires Node.js and esbuild:

# from nyora-web/ — production bundle into dist/
npm install
npm run build

The shared engine

The source-parsing logic lives in the public nyora-shared repository — the same parser bundle that powers every platform. The Windows, macOS and Linux desktop ports consume it directly as a Git submodule at nyora-shared/; the SDKs and apps embed an equivalent bundle. If you want to add or fix a source, that's the repo to target.

Building the engine for scripting instead of a full app? The Python SDK and JavaScript SDK run the same parser stack with no JVM, Java or desktop app — install with one package manager command and start browsing sources in a few lines of code.

Next steps

Getting started — install a prebuilt app and learn the basics.
FAQ — answers to common build, sync and source questions.
Cloud API & Sync — the cloud helper REST API (~960 sources) and the account + library sync contract.

Build from source