Download your dive computer, check the deco on the profile, plan tomorrow's dive with the gas you actually have, log who you dove with and what you saw, and keep every bit of it on your own hardware. Rec or tech, single tank or rebreather, it all fits in the same logbook.

Free and open source, on iOS, Android, macOS, Windows and Linux.

Comprehensive Dive Logging

Every dive, fully detailed and in your control.

• Depth, duration, temperatures, conditions, weather and tide
• Any number of cylinders: air, nitrox, trimix, CCR and SCR
• Buddies, divemasters, trips, tags, ratings and signatures
• Cards, or a sortable table with the columns you choose

Profile & Decompression Analysis

Serious technical-diving instrumentation.

• Bühlmann ZH-L16C with your own gradient factors
• All 16 tissue compartments, nitrogen and helium
• CNS%, OTU and ppO₂ with daily and weekly totals
• Your computer's NDL, ceiling and TTS beside the model's

350+ Dive Computers

Download straight from your computer.

• 30 manufacturers over Bluetooth LE and USB
• Incremental downloads: only what is new
• Duplicate review with four ways to resolve a match
• Two computers on one dive, profiles overlaid

Confirmed working: Shearwater Teric, Aqualung i300C, Aqualung i330R. Have a different dive computer? Help us expand this list. We are looking for testers.

Sites, Maps & Marine Life

Where you dove, and what lives there.

• 3,600 dive sites and 3,600 dive centers built in
• Clustering, a dive heat map, and offline map regions
• Bathymetry overlays and 3D seafloor terrain
• 685 species, recorded per dive and per site

Dive Planning & Gas

Plan with the gas, gear and tissues you will actually have.

• Multi-segment plans for OC, CCR, SCR and PSCR
• Bailout checked against the worst moment of the profile
• Contingencies, range tables and repetitive-dive seeding
• MOD, best mix, rock bottom, and a real-gas blender

Photos, Gear & Certifications

The rest of what a dive leaves behind.

• Photos and video matched to a dive by capture time
• Each shot marked at its depth on the profile
• Equipment with service schedules, reminders and costs
• A wallet of certification cards, plus courses and checklists

Statistics & Records

See your diving life at a glance.

• Ten pages: totals, progression, conditions, gas and more
• Personal records: deepest, longest, coldest, warmest
• Breakdowns by year, country, site and dive type
• SAC trends, depth distribution and ascent-rate analysis

Your Data, Encrypted

No server. No account. No lock-in.

• SQLite encrypted at rest, opened with Face ID, Touch ID or a passphrase
• End-to-end encrypted sync through your own iCloud, Google Drive, Dropbox or S3
• Encrypted backups, one taken automatically before every upgrade
• Export to UDDF 3.2, CSV, Excel, KML, GPX and printable PDF

_{Full-screen profile playback · The 16 tissue compartments as a landscape · A site's 3D seafloor with the dive's path}

_{Species sightings across the log · The blender's fill procedure and cost · Five themes, each in light and dark}

Why Submersion?

Most dive logging software falls into two categories: desktop applications stuck in the past, or mobile apps that lock your data in proprietary clouds. Submersion is different:

• You control your data: an SQLite database on your own hardware, encrypted at rest. No account, no server, no cloud dependency. Export everything, anytime.
• Truly cross-platform: one app for iOS, Android, macOS, Windows and Linux, with the same details and analytics everywhere. Available in 11 languages.
• Open standards: full UDDF 3.2 import and export, plus CSV, Excel, KML and GPX. No proprietary format trapping your dive history.
• 350+ dive computers: Bluetooth LE and USB, across 30 manufacturers, powered by libdivecomputer.
• Technical diving ready: Bühlmann ZH-L16C with gradient factors, multi-gas and CCR/SCR support, CNS and OTU tracking, bailout planning and trimix blending.
• Sync on your terms: end-to-end encrypted sync between your devices through your own iCloud, Google Drive, Dropbox or S3-compatible storage.
• Free forever: open source under GPL-3.0. No ads, no subscription, no in-app purchases.

Download

• macOS / Windows / Linux / Android: GitHub Releases
• iOS: App Store

Beta channel

Want fixes and features weeks early? Every change merged into Submersion is published as a beta build. Betas may upgrade your dive log's database ahead of the stable release; downgrading is not supported, and devices that sync together should all use the same channel. A backup is taken automatically before any database upgrade.

• Desktop: Settings > About > Update channel > Beta (updates then arrive through the normal auto-updater), or download directly from beta-builds
• Android: join the open test, then Play delivers beta updates automatically
• iOS / Mac App Store: join via TestFlight

Data Philosophy

Submersion is built on these principles:

1. Local-First: your data lives on your device. The app works offline, always.
2. No Lock-In: export your entire logbook to UDDF or CSV at any time. Switch apps without losing history.
3. No Account Required: use the app immediately. No sign-up, no email, no tracking.
4. Open Source: audit the code. Fork it. Improve it. Your dive log software should be transparent.

Features

Beyond what the screens above show.

Import from Elsewhere

• File import: Subsurface, MacDive, Shearwater Cloud, Garmin FIT, DAN DL7, Ratio and UDDF.
• CSV import: presets for MySSI, Diving Log, DiveMate, Garmin Connect and Shearwater Cloud, or map the columns yourself.
• Apple Health: underwater workouts recorded by an Apple Watch, with depth, temperature and heart rate.
• Paper logbooks: scan the pages and OCR reads the entries for you to check and import.

In the Log

• Conditions: visibility, current, swell, entry and exit method, altitude. Weather is fetched for the date and place; tides come from a bundled global model and work offline.
• People: your role on the dive, dive center, operator and boat. A buddy or instructor can sign the dive on your screen.
• Gas detail: oxygen and helium fractions per cylinder, start and end pressure, and the pressure trace from an air-integrated transmitter.
• Weights: what you carried, where you put it, and whether it felt right.
• Your own fields: colored tags, dive types you define, and custom fields for whatever your agency or your habits call for.
• Bulk edit: fix a whole trip's entries at once.
• Safety review: each profile is checked for fast ascents, sawtooth patterns and missed safety stops.
• Several divers: separate profiles per diver, each with emergency contacts, medical notes and insurance details.

Sites & Trips

• Site records: depth range, difficulty, water type, hazards, access notes, mooring and parking, with reverse-geocoded country and region.
• Reef data: protection status, habitat, bleaching alerts and reef health for the sites you visit.
• Trips: dates, resort or liveaboard, a day-by-day itinerary, preparation checklists, and a gallery for the whole trip.

Profile Analysis

• Playback: play or scrub the profile, overlaying temperature, tank pressure, heart rate, SAC, ppO₂, ppN₂, ppHe, gas density, gradient factor, TTS, ceiling, NDL and deco stops.
• Ascent rate: drawn on the profile and colored where it exceeds the limits.
• 3D: move through the dive in three dimensions, or view the 16 tissue compartments as a surface.
• Edit: trim a profile that started on the boat, with undo if you get it wrong.

Planning & Calculators

• Weighting: a buoyancy model built from your logged dives predicts what to carry for a new suit, cylinder or water type.
• Gas calculators: MOD, best mix, maximum narcotic depth, consumption and rock bottom.
• Blender: partial-pressure fills worked out with a real-gas equation, and the fill invoice.
• On the slate: export the plan as a PDF for your wet notes.

Equipment & Training

• Equipment sets: build a configuration once and apply it to a dive; a set can select itself by location.
• Service log: what was done, when, and what it cost.
• Courses: track a course's requirements and link each one to the dive that satisfied it.
• Checklists: run a pre-dive checklist from a template and attach the session to the log.

Data & Preferences

• Data quality: an assistant that finds duplicates and anomalies across the log and walks you through fixing them.
• PDF logbooks: Simple, Detailed, Professional, PADI and NAUI layouts.
• Your units: independent settings for depth, temperature, pressure, volume, weight, altitude and SAC.
• Your language: 11 languages, five themes in light and dark, and keyboard shortcuts on the desktop.

Getting Started

Prerequisites

• Flutter SDK 3.47.0 or newer (CI pins the exact version in .github/flutter-version.txt)

Quick Start

# Clone the repository
git clone https://github.com/submersion-app/submersion.git
cd submersion

# Initialize submodules (required for libdivecomputer)
git submodule update --init --recursive

# Install dependencies
flutter pub get

# Generate database and serialization code
dart run build_runner build --delete-conflicting-outputs

# Run the app
flutter run -d macos    # or: windows, linux, ios, android

Building on macOS without an Apple Developer account? flutter run -d macos builds the Debug configuration, which is pinned to the maintainer's signing team and will fail with No profiles for 'app.submersion' were found. See running a debug build without an Apple Developer account below. Linux, Windows, Android and the iOS Simulator need no signing setup.

Building from Source

Build for release (iOS, Android, macOS, Windows, Linux)

# iOS
flutter build ios

# Android
flutter build apk

# macOS
flutter build macos

# Windows
flutter build windows

# Linux
flutter build linux

Running a debug build without an Apple Developer account

flutter run -d macos builds the Debug configuration. On macOS that configuration pins CODE_SIGN_IDENTITY to Apple Development against the maintainer's Apple Developer team, so without access to that team Xcode cannot issue a provisioning profile and the build stops with:

error: No profiles for 'app.submersion' were found: Xcode couldn't find any
Mac App Development provisioning profiles matching 'app.submersion'.

Substituting your own team is not sufficient: macos/Runner/DebugProfile.entitlements requests an iCloud container, push notifications, an app group and a keychain access group, all of which are tied to the maintainer's account, and the app.submersion App ID is already registered and cannot be claimed by another team.

Sign the debug build ad-hoc instead. This requires no Apple account. Make both of the following local edits.

1. Sign the Debug configuration ad-hoc. In Xcode, open macos/Runner.xcodeproj, select the Runner target, go to Signing & Capabilities > Debug, uncheck Automatically manage signing and set Team to None. To edit macos/Runner.xcodeproj/project.pbxproj by hand instead, find the Runner target's Debug configuration (the block containing CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; that ends with name = Debug;) and change three settings:

-				CODE_SIGN_IDENTITY = "Apple Development";
+				CODE_SIGN_IDENTITY = "-";
-				CODE_SIGN_STYLE = Automatic;
+				CODE_SIGN_STYLE = Manual;
-				DEVELOPMENT_TEAM = 8U3RSKF42Q;
+				DEVELOPMENT_TEAM = "";

2. Remove the account-bound entitlements. Replace macos/Runner/DebugProfile.entitlements with the sandbox permissions that do not depend on a developer account:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
	<key>com.apple.security.app-sandbox</key>
	<true/>
	<key>com.apple.security.cs.allow-jit</key>
	<true/>
	<key>com.apple.security.device.bluetooth</key>
	<true/>
	<key>com.apple.security.device.serial</key>
	<true/>
	<key>com.apple.security.device.usb</key>
	<true/>
	<key>com.apple.security.files.user-selected.read-write</key>
	<true/>
	<key>com.apple.security.network.client</key>
	<true/>
	<key>com.apple.security.network.server</key>
	<true/>
	<key>com.apple.security.personal-information.location</key>
	<true/>
	<key>com.apple.security.personal-information.photos-library</key>
	<true/>
</dict>
</plist>

flutter run -d macos then builds and runs with hot reload. iCloud sync, push notifications and Google Sign-In are unavailable in this build; dive logging, the database, dive computer downloads over Bluetooth and USB, and file import and export all work.

Keep these edits out of your pull requests. Both files are tracked. Do not stage them, and restore them before you push:

git restore macos/Runner.xcodeproj/project.pbxproj macos/Runner/DebugProfile.entitlements

Other platforms need no signing setup. Linux, Windows and Android build from a clean checkout as-is, and so does the iOS Simulator: the iOS Debug configuration does not pin a signing identity, so the simulator SDK signs ad-hoc and never consults a developer account. flutter run -d ios against a simulator works without any of the edits above. Building for a physical iPhone does need the maintainer's team and is not currently possible for outside contributors.

For a release build without a certificate, no edits are needed. Use the no-sandbox script described under "macOS: building without a developer certificate" below.

macOS: building without a developer certificate

If you don't have an Apple Developer certificate, you can still build and run the app locally using ad-hoc signing. This creates a non-sandboxed build that works on any Mac.

# Run the no-sandbox build script
./scripts/release/build_nosandbox_macos.sh

This script:

1. Builds the macOS app with Flutter
2. Re-signs it with an ad-hoc signature (no Apple certificate required)
3. Applies no-sandbox entitlements for full file system access

The built app will be at build/macos/Build/Products/Release/submersion.app.

Running the app: macOS Gatekeeper will block unsigned apps by default. To run:

1. Right-click (or Control-click) on submersion.app
2. Select "Open" from the context menu
3. Click "Open" in the dialog that appears

You only need to do this once; subsequent launches will work normally.

Note: This build cannot be distributed via the Mac App Store (which requires sandboxing). It's intended for local testing and direct distribution.

Windows: building from source

Windows builds require no code signing for local use. You need Visual Studio with the Desktop development with C++ workload installed (the free Community edition works).

# Build the app
flutter build windows --release

The built app will be at build\windows\x64\runner\Release\.

Note: Windows SmartScreen may show an "unrecognized app" warning for unsigned executables. Click "More info" then "Run anyway" to proceed.

Linux: installing

Distro requirement: Submersion needs glibc 2.38 or newer, which means Ubuntu 24.04+, Debian 13+, Fedora 39+, Linux Mint 22+, Arch, or openSUSE Tumbleweed. Debian 12, Ubuntu 22.04, and RHEL 9 cannot run any current Submersion build. The packages install but the app will not start, and the tarball fails the same way, because three bundled libraries require GLIBC_2.38. Upgrading the distribution is the only path.

Where the packages are today: the .deb and .rpm ship with every beta build at submersion-app/beta-builds. They reach the stable Releases page with the next stable release; that page currently carries the tarball only.

Debian, Ubuntu, Mint, and derivatives

Download Submersion-v<version>-Linux-amd64.deb from beta releases, then:

sudo apt install ./Submersion-*-Linux-amd64.deb

Fedora and RHEL

Download Submersion-v<version>-Linux-x86_64.rpm from the beta releases, then:

sudo dnf install ./Submersion-*-Linux-x86_64.rpm

openSUSE

The same .rpm, installed with zypper, which openSUSE ships instead of dnf:

sudo zypper install ./Submersion-*-Linux-x86_64.rpm

Both packages install a desktop entry, icons, and udev rules that let dive computers connected by USB be reached without any group membership or usermod step. Video compression is optional and needs ffmpeg, which the packages recommend but do not require.

Everything else (Arch, NixOS, and anyone who prefers not to install packages)

Download Submersion-v<version>-Linux.tar.gz, unpack it, and run the included installer:

tar xzf Submersion-*-Linux.tar.gz
./install.sh

install.sh checks for missing shared libraries and prints the exact command to install them for your package manager, installs a desktop entry and icon into ~/.local/share, and links the binary into ~/.local/bin. It also prints the command to install the udev rules, which needs root. ./uninstall.sh reverses all of it and never touches your dive log data.

Linux: building from source (distro dependencies)

Linux builds require GTK3 and several native development libraries. Install them first:

Debian/Ubuntu:

sudo apt-get update
sudo apt-get install -y \
  clang cmake ninja-build pkg-config \
  libgtk-3-dev liblzma-dev libstdc++-12-dev \
  libsqlite3-dev libsecret-1-dev

Fedora:

sudo dnf install -y \
  clang cmake ninja-build pkg-config \
  gtk3-devel xz-devel libstdc++-devel \
  sqlite-devel libsecret-devel

Arch Linux:

sudo pacman -S --needed \
  clang cmake ninja pkg-config \
  gtk3 xz sqlite libsecret

Then build:

flutter build linux --release

The built app will be at build/linux/x64/release/bundle/.

Architecture & tech stack

Submersion follows clean architecture principles with clear separation of concerns:

lib/
├── core/                 # Shared infrastructure
│   ├── database/         # Drift ORM schema and migrations
│   ├── deco/             # Decompression algorithms
│   ├── router/           # Navigation (go_router)
│   ├── services/         # Location, weather, database services
│   └── theme/            # Material 3 theming
├── features/             # Feature modules
│   ├── dive_log/         # Core dive logging
│   ├── dive_sites/       # Site management & maps
│   ├── dive_computer/    # Device connectivity
│   ├── equipment/        # Gear tracking
│   ├── statistics/       # Analytics & records
│   └── ...               # Additional features
└── shared/               # Reusable widgets

Tech Stack:

• Flutter: cross-platform UI framework
• Riverpod: reactive state management
• Drift: type-safe SQLite ORM with migrations
• go_router: declarative navigation
• fl_chart: interactive charts for profiles and statistics
• flutter_map: OpenStreetMap integration
• libdivecomputer: FFI bindings for dive computer communication

See ARCHITECTURE.md for detailed documentation.

Roadmap

See FEATURE_ROADMAP.md for what is built, what is in progress, and what is planned.

Contributing

Contributions are welcome! Submersion is built by divers, for divers.

1. Fork the repository
2. Clone and initialize submodules: git clone --recurse-submodules <your-fork-url>
3. Create a feature branch: git checkout -b feature/your-feature
4. Make your changes with tests
5. Submit a pull request

Please run flutter analyze and flutter test before submitting.

License

Submersion is free software, released under the GNU General Public License v3.0.

You are free to use, modify, and distribute this software. If you distribute modified versions, you must also release the source code under GPL-3.0.

See LICENSE for the full text.

Acknowledgments

Submersion builds on the work of the dive logging community:

• libdivecomputer: the open-source library powering dive computer communication
• Subsurface: inspiration and the UDDF format
• Flutter: cross-platform framework making this possible

---

Dive safe. Log everything. Own your data.