Contributing

Memospot contributor’s guide.

License

By contributing, you agree that all your contributions will be licensed under the MIT License.

In short, when you submit code changes, your submissions are understood to be under the same MIT License that covers the project. Feel free to contact the maintainer if that’s a concern.

Localization

This project is available in multiple languages. You can join the Crowdin platform to help make it accessible to a broader audience!

Development

The recommended code editors are Zed and Visual Studio Code. The project has a pre-configured workspace, which will prompt you to install the recommended extensions.

Coding style

• Try your best to match the existing code style.
• Run just pre-commit on the repository before submitting a pull request. This will run all the code formatters, linters and tests.

Container build

It’s possible to build the app for Linux and Windows (NSIS installer only) using Docker Bake. It just needs a working Docker installation.

This bypasses the need to setup the tooling on the host OS.

How to

Usage

Available actions:

• CI
  • lint
  • test
• Release
  • linux
  • windows
• Release (no-bundle)
  • linux-no-bundle
  • windows-no-bundle

just bake [action]

sudo

The just recipe is configured to run Docker with sudo, as it’s the standard way to do it.

For a rootless Docker install, edit the justfile or invoke docker buildx bake [action].

or

docker buildx bake [action]

See docker-bake.hcl for all available targets.

Pruning caches

Tip

Prune the builder cache when you are done with building.

just bake prune

or

docker builder du && docker builder prune -a

Pre-requisites for host machine

• A package manager: Homebrew or winget.
• A system WebView (Edge WebView2, Safari, or WebKitGTK).
• A modern computer, with at least 8 GB of RAM and a decent CPU.
• 20 GB of free disk space, for Rust artifacts.

Important

After installing a tool, make sure its directory is listed in your system PATH environment variable.

Open a new terminal window and try to run the tool from there. If it doesn’t work, read the tool’s installation instructions thoroughly and setup it accordingly.

OS-specific dependencies

See also: Tauri Prerequisites

Linux

sudo apt update -y &&
sudo apt install --no-install-recommends -qq \
    autoconf \
    autotools-dev \
    build-essential \
    ca-certificates \
    curl \
    file \
    patchelf \
    wget \
    git \
    unzip \
    nsis \
    clang \
    lld \
    llvm \
    libayatana-appindicator3-dev \
    libgtk-3-dev \
    librsvg2-dev \
    libssl-dev \
    libwebkit2gtk-4.1-dev \
    libxdo-dev \
    jq \
    -y

macOS

xcode-select --install

Windows

1. Git

winget install --id Git.Git -e --source winget

2. Build Tools for Visual Studio 2022

winget install -e --id Microsoft.VisualStudio.2022.BuildTools --override "--passive --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended"

3. Edge WebView2

winget install --id=Microsoft.EdgeWebView2Runtime -e

Tooling

Bun

Bun is a fast JavaScript/TypeScript runtime, bundler, test runner, and package manager. It’s used to bundle the front end and to run build scripts.

Homebrew

brew install oven-sh/bun/bun

Winget

winget install --id Oven-sh.Bun

jq

jq is a lightweight and flexible command-line JSON processor.

Homebrew

brew install jq

Winget

winget install --id=jqlang.jq -e

Rust

Rustup | Website

Homebrew

brew install rustup-init
rustup-init -y
source "$HOME/.cargo/env"

Winget

winget install --id Rustlang.Rustup

Rust toolchain

rustup default stable
rustup component add clippy rust-analyzer

Cargo binstall

Binstall is a tool for installing pre-built Rust binaries.

Homebrew

brew install cargo-binstall

Windows (Powershell script)

Set-ExecutionPolicy Unrestricted -Scope Process; `
iex (iwr "https://raw.githubusercontent.com/cargo-bins/cargo-binstall/main/install-from-binstall-release.ps1").Content

Script source

Cargo (build from source)

cargo install cargo-binstall --locked

Rust tools

• cargo-cache: Utility to manage cargo cache.
• cargo-edit: Utility to manage cargo dependencies.
• cargo-xwin: Cross compile Cargo projects to Windows.
• dprint: A pluggable code formatter.
• just: A command runner.

Linux/macOS

cargo binstall \
    --disable-telemetry \
    --locked \
    --force \
    --targets=$(rustc -vV | sed -n 's|host: ||p') \
    cargo-cache@0.8.3 \
    cargo-edit@0.13.8 \
    cargo-xwin@0.20.2 \
    dprint@0.50.2 \
    just@1.45.0 \
    tauri-cli@2.9.5 \
    -y

Windows (PowerShell)

cargo binstall `
    --disable-telemetry `
    --locked `
    --force `
    --targets=$(& rustc -vV | Select-String -Pattern "^host:" | ForEach-Object {$_.Line.Split(':')[1].Trim()}) `
    cargo-cache@0.8.3 `
    cargo-edit@0.13.8 `
    dprint@0.50.2 `
    just@1.45.0 `
    tauri-cli@2.9.5 `
    -y

System path

cargo binstall outputs the installed tools to $HOME/.cargo/bin which already should be in your PATH environment variable so the tools can be found from the terminal.

Memos server build

Memos server is built separately on the repository memos-builds.

A pre-build hook script will automatically download the latest release from the companion repository and put it in the server-dist folder, with the appropriate name.

Downloaded files will be reused on subsequent builds.

Memos version

You can set the environment variable MEMOS_VERSION, so the build script will download the specified version from the companion repository.

Manual server build

Caution

If you build Memos by yourself, you must put the appropriate binary in the server-dist directory, so Tauri can bundle it with the app.

Server binaries must be named using target triples.

Sample valid server binary names:

• Windows: memos-x86_64-pc-windows-msvc.exe
• Linux: memos-x86_64-unknown-linux-gnu
• macOS: memos-x86_64-apple-darwin memos-aarch64-apple-darwin

Tip

You can check your current system target triple with the command rustc -vV.

Cloning the repository

git clone https://github.com/memospot/memospot.git
cd memospot

At this point, everything should be ready to go.

Using Just

This project’s workflow is heavily based on Just, a modern alternative to Makefiles and scripts.

A justfile is available with several pre-configured recipes for this project. Just installation is covered under the Cargo binstall section.

On Windows, you must allow script execution in PowerShell

Set-ExecutionPolicy -ExecutionPolicy RemoteSigned -Scope CurrentUser

Common recipes

just dev	Run the app in development mode
just build	Build the app
just fmt	Run all code formatters
just lint	Run all code checkers/linters
just test	Run all available tests
just clean	Remove build artifacts and caches

List all available Just recipes

just --list

Troubleshooting

Linux

soup3-sys

Should you experience an error regarding soup3-sys, set PKG_CONFIG_PATH manually:

export PKG_CONFIG_PATH="/usr/lib/x86_64-linux-gnu/pkgconfig/:/usr/share/pkgconfig"

You can make this permanent by adding that line to your shell profile (~/.bashrc, ~/.zshrc, etc).

macOS

cargo-tauri

Should you experience issues with cargo-tauri, like bad CPU type in executable, try building it manually:

cargo install --locked --force --target=$(rustc -vV | sed -n 's|host: ||p') tauri-cli