Mnema Talk desktop
From mnema-talk-desktop v1.4.0, rendered on this site.
It wraps the same Vue web app as the browser, with two additions: it removes server-served JavaScript from the trust equation, and it helps you stay in a Talk while you play. Windows and macOS run it in a Tauri host. Linux runs it in Electron, because the WebKitGTK that Tauri uses on Linux has no WebRTC.
Status: Beta, unsigned. The
browser app is the primary, fully supported client. This client is Beta: usable
and maintained, but not signed with a platform certificate, so Windows
SmartScreen and macOS Gatekeeper warn on first start (steps below), and it has
not been qualified on real hardware for macOS and Linux. It updates itself from
signed releases, see below. Windows CI checks the WebView2
custom-protocol origin, which window may ask for a microphone, and the gaming
surfaces. The host passes a synthetic capture device as a WebView2 browser
argument for that run, because the runtime replaces
WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS. The instance window leaves the
request on WebView2's own prompt, which the check does not click, and the
other windows are refused. A human permission prompt, physical devices and
sealed media on real hardware are still outstanding. The macOS build has
had less testing still (see macOS). See the
product status.
There is no external security audit.
What it adds to the browser
- A signed web app instead of server code. The client runs a signed web bundle that it verifies on every start (Ed25519, key pinned in the client). The server supplies data, never executable code, so a compromised server cannot inject JavaScript that reads your end-to-end encrypted media. The bundle is checked against the server's API version and a rising security floor, older bundles are refused, and updates come from the Mnema Talk releases. Design and threat model: desktop-trusted-client.md.
- The session stays in the OS keychain (Windows Credential Manager, macOS Keychain, the secret service on Linux), not in a web profile.
- OS notifications and an app badge. Messages that would raise a browser
notification show as native toasts instead (Windows, macOS, Linux), and the
unread mention count appears on the taskbar, dock or launcher icon. Clicking
a toast opens the window at its message. On macOS the system asks once
whether Mnema may show notifications (UserNotifications); on Windows the
installer's Start-menu shortcut registers the app for toasts. The instance
window announces the
notifycapability; web bundles from before this feature keep working with the browser's own notifications. - Downloads you can find. A file a server's page offers for download (your data export, an attachment from the media viewer) is fetched by the client itself and streamed to disk, whatever its size: on Windows and macOS into the Downloads folder, never over an existing file, marked as downloaded from the internet (as a browser marks it) and shown selected in Explorer or Finder; on Linux where the save dialog says. One download per server runs at a time. A download that saved nothing says why and what to do next in an error dialog; a partial file is never left behind.
- One client, any number of servers. A rail on the left lists your servers
with an unread dot and a mention count each. Add as many as you like: there
is no server limit; the list file can be up to 8 MiB (room for 100 000
servers and more), and an import of thousands is taken at once. The rail scrolls when they do not fit and keeps
the server in front in view.
Switch with Ctrl+1 to Ctrl+8 for the first eight and Ctrl+9 for the last (Cmd
on macOS), as browsers do with tabs, or with Ctrl+K; drag or Alt+arrow to reorder, and remove one
from its menu (right-click or Delete). The same menu sets your notification
level for that server (all messages, only mentions, mute) on servers that
support it (Mnema Talk 1.2 and newer). Group servers in folders (drop one
server onto another, or "Add to folder" in the menu), name a folder and give it
a colour, close it to a small grid of its servers with the total of its
mentions, and rename a server for this device only: the name the server gives
itself stays in the tooltip. The menu is the system's own, so it is never cut
off by the server's page. Where the server's Owner has set an icon for the
community, the rail shows it (fetched from that server only, as a png or webp
of at most 1 MiB, kept next to the other data of the server). Folders, names
and order are kept in the list of servers, next to the exe in the portable
build. Right-click also mutes a server (1 h, 8 h, until tomorrow, for good: no
toasts, no count in the badge), marks everything read, and the + button's
menu exports and imports the list of servers as a JSON file. Ctrl/Cmd+K
opens a quick switcher over the servers. A link to an invite of a server you
have not added offers "Add this server". One account per server, no federation:
every server has its own session in the keychain, its own browser storage
(a WebView2 profile per server on Windows, a data store per server on macOS
14 and newer, a session partition on Linux) and its own connection. Removing a
server wipes its stored session and its local data from this device. The
taskbar or dock badge is the sum of the mentions; a toast names its server
and brings it to the front when used. A server's page costs about 110 to
260 MB, so pages are made only when needed and closed when idle: at start
only the server in front loads, an imported list adds servers to the rail
and opens nothing, and a page hidden for more than 10 minutes is closed
while more than 4 run, unless it holds an unsent draft, an upload or a Talk
(it says so itself; a page from an older web app never does and is never
closed). Opening the server loads its page again. Until then the client
keeps its counts on the rail and the badge itself, from the server's own
unread summary and direct messages, read again whenever the server says
something changed (a signed-out session clears them until the page is opened
again; an unreachable server is asked again later and later, up to five
minutes); it
listens on a socket of its own that tells the server you are away there,
exactly as the hidden page did, and sends nothing else. The 64 servers used
most recently keep such a socket; the others are read every minute instead,
without a socket. Your presence on those servers is then not kept up: they
show you as offline rather than away until you open them again. A long list
costs neither open files nor a socket on every server (on macOS the client
also raises its open-file limit from the 256 an app gets). The first counts after a server starts announce nothing. When its mentions
rise, one quiet notification says "N new mentions on
" (no sound, none for a muted server, only where the system already lets the app notify). Both values are settings of this device: the + button's menu has Unload idle servers (Off, after 10 minutes, after 1 hour); in the list file they are "sleep": {"after_secs": 600, "keep": 4}("after_secs": nullnever closes a page; another time reads as the nearest of the three; at least one page), never part of an exported list. Overlay and shortcuts of the gaming integration belong to the server that owns the Talk you are in. Updating from the single-server client (1.1 release note): that client kept every server in one shared storage and did not record which one it showed, so the storage belongs to no one server. On the first start of this version it is wiped, once, and no server inherits it: you sign in again, and the end-to-end media gets a new device key (messages live on the server and are unaffected). The host's own pages use a separate storage. On macOS before 14 the data stores cannot be separated, so the client runs one server there. Servers on different versions work side by side: each runs the verified web app that fits it, and one that is too old or too new says so in its own tab. See desktop-trusted-client.md. - Gaming integration (Windows). A left-hand sidepeek shows who is in your
Talk, who is speaking and who is sharing, and
Alt+Mopens an interactive overlay with Talk controls, while you have a connected Talk and a detected foreground game. Shortcuts for mute, deafen, push-to-talk and the overlay are configurable. See the gaming guide for setup and its limits (topmost windows, not exclusive fullscreen). Game detection and push-to-talk are event driven (no polling, no process enumeration, no injection, no keyboard hook); GAMING.md is the reference, including the anti-cheat safety statement. The gaming integration is Windows only. macOS and Linux ship the client without it.
Troubleshooting
On Windows and macOS every connection the client makes to a server (and to GitHub for updates) uses TLS 1.2 or 1.3, and the certificate is checked by the operating system's own trust store, including roots you or your administrator added. A certificate the system rejects is rejected here too.
- A TLS 1.3-only server is unreachable (the error says "bad protocol
version" or
os error -2146893054): this affected versions before 1.2.12 on Windows 10 and macOS. Update to 1.2.12 or later.
Get it
Every release also carries the installers under names without the version, so
these links always download the newest one (each file is identical to the
versioned one next to it and listed in the release's SHA256SUMS):
| Platform | Direct link |
|---|---|
| Windows installer (x64) | mnema-desktop-windows-x64-setup.exe |
| Windows portable ZIP (x64) | mnema-desktop-windows-x64-portable.zip |
| macOS (Apple silicon) | mnema-desktop-macos-arm64.dmg |
| Linux .deb (x86_64) | mnema-desktop-linux-x64.deb |
| Linux .deb (arm64) | mnema-desktop-linux-arm64.deb |
| Linux AppImage (x86_64) | mnema-desktop-linux-x64.AppImage |
| Linux AppImage (arm64) | mnema-desktop-linux-arm64.AppImage |
The updater feed and its signatures name only the versioned files.
Download Mnema-Desktop_<version>_x64-setup.exe from the
latest release
and run it once. It installs for the current user only (no administrator
prompt) and updates itself from then on. SmartScreen warns because the installer
has no Authenticode certificate; the self-update does not depend on one (see
below). The portable ZIP of each release updates itself as well: it downloads the signed portable ZIP of the new release, verifies it against the same pinned key, puts the new program in place of the old one (the old one is deleted at the next start) and restarts; the folder has to be one you can write to. It keeps its settings, server list and browser data in a mnema-data folder beside the program (or in the absolute folder named by MNEMA_DESKTOP_DATA_DIR). The first start copies the client's own files that an earlier portable version kept in %LOCALAPPDATA%\com.mnema.desktop.shareddev and %APPDATA%\com.mnema.desktop.shareddev (not the browser engine's data, so you sign in to your servers again); it does that once, and it does not delete them: remove those two folders by hand when you no longer need them. Deleting mnema-data resets the portable copy. Saved passwords live in the Windows credential store, as for any Windows program. To build from
source, see experimental/README.md:
Rust and Node, with mnema-talk checked out next to this repository. The older
Windows DEV ZIP attached to
mnema-talk releases through v0.7.3
still loads the server's JavaScript and predates the signed bundle.
macOS
Download Mnema-Desktop_<version>_aarch64.dmg from the
latest release
(Apple silicon, M1 or newer, macOS 12 or newer), open it and drag the
app to Applications. It updates itself from then on.
The app is ad-hoc signed, not notarized: there is no Apple Developer account behind it, so Gatekeeper refuses it on the first start ("cannot be opened because Apple cannot check it for malicious software"). Pick one:
- macOS 15 and newer: try to open the app once, then open System Settings → Privacy & Security, scroll to the message about Mnema Desktop and choose Open Anyway.
- macOS 14 and older: right-click the app and choose Open, then Open again.
- Terminal:
xattr -dr com.apple.quarantine "/Applications/Mnema Desktop.app"
This is needed once: the self-update downloads inside the app and does not mark the new version as quarantined, so later versions start without it. The update is still verified by the pinned minisign key (see below); Gatekeeper plays no part in that. The first time you speak, share the camera or share the screen macOS asks for the microphone, camera or screen recording permission (System Settings → Privacy & Security lists them for Mnema Desktop). Because every version is a new ad-hoc signature, macOS may also ask once after an update whether the app may use its keychain entry; if you decline, you sign in again. There is no gaming overlay on macOS.
Linux
Download from the latest release the file for your machine, x86_64 (also called amd64) or arm64:
- AppImage,
Mnema-Desktop_<version>_x86_64.AppImageor..._arm64.AppImage: make it executable (chmod +x) and run it. It needs no installation and no FUSE, and it updates itself (see Updates). - .deb,
Mnema-Desktop_<version>_amd64.debor..._arm64.deb, for Debian and Ubuntu:sudo apt install ./Mnema-Desktop_<version>_amd64.deb. It installs to/opt/Mnema Desktopwith a menu entry and an AppArmor profile, and updates itself through the package manager: the client verifies the signed package, then asks for your password (polkit) to install it.
At the first start enter the HTTPS address of your community's instance, as on
the other platforms. Your data (the verified web apps, the trust statement, the
browser storage of the app) lives in ~/.config/mnema-desktop; MNEMA_DESKTOP_DATA_DIR
points the client somewhere else.
Why Electron. The Tauri host would need WebKitGTK on Linux, which has no
WebRTC, so voice and screen sharing could not work. Electron ships Chromium. The
verification of bundles, the trust statement, the rollback marks, the proxy and
the session cookie are a port of the Tauri host to TypeScript, run against the
same test vectors as the Rust code (test-vectors/); see linux/README.md
for the design. Windows and macOS are unchanged.
The sandbox. Chromium isolates the page in a sandbox that needs
unprivileged user namespaces. Ubuntu 24.04 and newer restrict them by default
(AppArmor), and the AppImage launcher then silently drops the sandbox. The
client refuses to start without the sandbox and says so. Use the .deb
(its AppArmor profile permits the app), or allow namespaces
(sudo sysctl -w kernel.apparmor_restrict_unprivileged_userns=0), or accept the
risk with MNEMA_DESKTOP_ALLOW_NO_SANDBOX=1.
The session. The session cookie is kept encrypted with a key in the secret
service (GNOME Keyring, KWallet, anything that speaks libsecret). Without a
secret service Chromium would only use a fixed password, which is no protection,
so the client falls back to a private file (mode 600) in its data directory, as
the other platforms do where no keychain exists: copies of the profile and
backups that cannot read that file do not carry the session, but another
program of your user can. MNEMA_DESKTOP_NO_VAULT=1 chooses the file on
purpose.
Wayland and screen sharing. The client asks Chromium to pick Wayland on a
Wayland session (--ozone-platform-hint=auto) and X11 otherwise. On Wayland, screen sharing goes
through PipeWire and the desktop portal: you need xdg-desktop-portal and the
backend for your desktop (xdg-desktop-portal-gnome, -kde or -wlr) and
PipeWire; the portal's own dialog asks which screen or window to share. On X11
the client shows its own list with previews. Sharing the sound of a screen
is not available on Linux (Electron captures system audio only on Windows and
macOS); the microphone and camera work as in any Chromium. Hardware video
encoding is Chromium's, and is off on many Linux setups; where the driver
supports it, --enable-features=VaapiVideoEncoder turns on VA-API.
Private certificate authorities. Certificates are checked against the
system store, like the other platforms, so a community on a private CA works
once the CA is installed system-wide (update-ca-certificates on Debian and
Ubuntu). NODE_EXTRA_CA_CERTS is deliberately switched off in the program.
Not available. The gaming overlay is Windows only. MNEMA_DEBUG_PROTOCOL=1
logs what the client serves. A packaged client does not open a remote debugging
port and does not accept ELECTRON_RUN_AS_NODE, NODE_OPTIONS or --inspect.
Updates
Two things update, both from GitHub, both verified before use:
The web app (the signed bundle) as described in doc/desktop-trusted-client.md.
The program itself through the official Tauri updater (Windows installer, macOS), from its own signed ZIP (Windows portable copy) or, on Linux, the same signed feed read by the Electron client (below). The client checks
releases/latest/download/latest.jsonof this repository at every start and then every six hours (the same interval as the bundles; a failed check is tried again after 15 minutes). When a newer version exists, a calm Update pill appears at the foot of the server rail and stays until the update is done or skipped, and the app menu (Updates on Windows and Linux, the application menu on macOS) gets a dot, Update now, Check for updates… and the installed version. No window opens by itself. Update now (the pill or the menu) downloads with progress in the pill, verifies, installs and restarts the app; the servers, sign-ins and settings stay. During a Talk it asks first: After the call downloads and verifies now and installs once the Talk has ended, Update now installs at once. The update window (a click on the pill while an update runs, waits or failed) also offers On next start (download now, install when the client is next started; not for the portable copy) and Skip this version, and links to the release page. A failed attempt says in a plain sentence what went wrong and what to do next, lets you copy the error, and can be retried.MNEMA_DESKTOP_NO_UPDATE_CHECK=1turns both checks off.Installed from What Update now does Windows installer runs the signed new installer (per user, no administrator prompt), which restarts the app Windows portable ZIP downloads the signed portable ZIP, renames the running program aside, puts the new one and its files in place (never mnema-data) and restarts; the old program is deleted at the next startmacOS disk image replaces the app in place from the signed app archive and restarts Linux AppImage replaces the AppImage file it was started from and restarts Linux .debverifies the signed .deb, then the system asks for your password (polkit) and the package manager installs it; without polkit the package opens in the software installer
From "Mnema Desktop DEV"
Up to 1.3.5 the app was called Mnema Desktop DEV. From 1.4.0 it is
Mnema Desktop, and an installed copy updates in place. Your servers,
sessions and settings stay: they are kept under the app's identifier
(com.mnema.desktop.shareddev), which did not change.
- Windows: the update removes the old copy with its own uninstaller and
installs the new one in
%LOCALAPPDATA%\Mnema Desktop(a folder you chose yourself stays). The entry under Installed apps and the Start menu and desktop shortcuts take the new name. A shortcut pinned to the taskbar points at the old program and has to be pinned again. CI checks this on every change (windows-update-from-dev,scripts/test-windows-rename-update.ps1). - macOS: the update replaces the app where it is, so it keeps the name
Mnema Desktop DEV.appin Applications; a new download is calledMnema Desktop.app. The app itself shows the new name. - Linux: the
.debkeeps its package namemnema-desktop-devand its command, so it upgrades in place and moves from/opt/Mnema Desktop DEVto/opt/Mnema Desktop. An AppImage is replaced where it lies and keeps its file name. CI checks both (scripts/upgrade-from-dev.sh).
An update is installed only if its minisign signature verifies against the
public key pinned in experimental/app/tauri.conf.json, the version the
signature was made for equals the announced version, and that version is newer
than the installed one. Where the file came from (GitHub, a mirror, a proxy)
decides nothing. The matching private key exists only as a secret of the
protected desktop-updater-signing environment (tags v*) and in the owner's
offline backup.
Releasing
- Raise the version in
experimental/app/tauri.conf.json,experimental/app/Cargo.tomlandexperimental/app/Cargo.lock, and inlinux/package.jsonandlinux/package-lock.json, together (scripts/check-release-version.mjs vX.Y.Zchecks this) and merge it tomain. - Push the tag
vX.Y.Zon that commit.desktop-release.ymlre-tests, builds the tested executable into an NSIS installer, signs it in the protected environment, smoke-installs it per user on a Windows runner, checks thatlatest.jsonverifies against the pinned key and publishes the installer, its.sigfile,latest.json, a portable ZIP and its.sigfile, the macOS disk image and updater archive, the Linux AppImages and.debpackages, unversioned copies of those seven installers (scripts/stable-asset-names.mjs, for the links under Get it), andSHA256SUMS. The release is public only after everything is attached. The Tauri host on Linux is not built.
To rehearse a release without publishing, run desktop-release.yml by hand
(gh workflow run desktop-release.yml --ref main -f version=X.Y.Z). It runs
the same jobs and checks for that version, creates no release and moves no tag,
and uploads the files, latest.json and SHA256SUMS as the artifact
mnema-desktop-rehearsal. It never enters the signing environment: each signing
job makes a throwaway key, and the artifact carries only their public halves
(rehearsal-updater-*.pub), which the feed is verified against.
Rotating or revoking the updater key
Installed clients trust exactly the key in their own tauri.conf.json.
To rotate: generate a new pair (tauri signer generate), publish a release that
contains the new public key but is signed with the old key, then switch the
secrets to the new key. Clients that took that release trust the new key from
then on. A release signed with a key a client does not have cannot be installed
by it. If the old key is lost or compromised and no release carrying the new
key reached a client, that client must install the new version manually from
the release page. Revoking a single release is done by publishing a higher
version; clients never go back to a lower one.
Remote revocation. The client also pins an offline root key (never in CI).
At start and every six hours it fetches a statement signed by that key from
desktop-trust/ in the mnema-talk repository. The statement lists the web
bundle keys and updater keys that are allowed and the ones that are revoked;
the client keeps the last good one, refuses a lower serial or an expired
statement, drops bundles signed by a revoked key (the rollback marks a revoked key
raised are cleared, those of trusted keys stay; a statement can also cap them
with max_version), and refuses updates signed by a revoked updater key. A statement is
valid for 180 days; while the one in force has expired, or its fetch failed in
a round, the client installs nothing new and keeps running what it has. A
client only counts a statement as fresh after fetching it in the current run. An installer kept for the next start is applied at startup, before the main window loads, after that fetch succeeds and the installer has been re-verified against the fresh statement's keys; if the fetch fails it stays kept and the next start tries again.
The owner must re-sign about every 3 months (trust sign -renew, see the
mnema-talk doc). If a CI key leaks, the owner issues a new statement instead of racing the
attacker with a release. The runbook is in mnema-talk
doc/desktop-trusted-client.md ("Key revocation"). A replacement updater key
listed in the statement is used to verify updates, so the key in
tauri.conf.json can be replaced without a client that has missed a release.
On macOS the updater replaces the app in place from the signed
.app.tar.gz; latest.json carries a darwin-aarch64 entry.
On Linux the feed carries linux-x86_64 and linux-aarch64 entries that name
the signed AppImages, and linux-x86_64-deb and linux-aarch64-deb entries that
name the signed .deb packages. Tauri clients look up their own platform and
ignore these (the entries use the same fields, so nothing in the file changed
for them). The
Electron client applies the same rules as the Tauri updater, in TypeScript: the
minisign signature must verify against the pinned key (or a replacement key
the trust statement lists, and never a revoked one), the version recorded inside
the signature must equal the announced one, the version must be newer than the
running one, the download must be an HTTPS URL on github.com, and nothing new
is installed without a trust statement fetched in the current run. The pill,
the menu and the window offer the same choices (Update now, After the
call, On next start, Skip this version). The Linux client counts a
Talk as running while a server's page plays media (the voices of the others);
alone in a Talk nothing plays, and the update does not wait.
Update now replaces the AppImage file it was started from (a failed write
leaves the installed one untouched) and restarts it; On next start keeps the
verified AppImage and installs it, after verifying it again, at the next start.
A .deb installation is updated through the package manager: the client reads
its own -deb entry, verifies the package the same way, and hands it to
pkexec, which asks for your password; it never writes under /opt itself. An
installation of neither kind only gets a link to the release page. The AppImage has to be in a
directory you can write to.
At startup, enter the HTTPS address of your community's instance. Microsoft Edge WebView2 Runtime is required on Windows; macOS uses the system WebKit; Linux brings its own Chromium. Packages are unsigned, so SmartScreen warns, and a checksum only detects a damaged download; it does not prove who built it.
Repository
| Path | What |
|---|---|
experimental/app | The Tauri host: instance selector, bundle verification, proxy, keychain, gaming surfaces |
linux | The Linux client (Electron): the same verification, proxy and updater in TypeScript; AppImage and .deb |
test-vectors | Cases shared by the Rust host and the Linux client: bundles, rollback marks, trust statements, proxy rules, minisign |
src | The gaming logic (foreground tracking, game matching, input state machines) the host includes by path; the root crate builds it on its own so its tests run on every system |
ui | Pins the Tauri CLI that the workflows use to bundle the installer |
scripts | Build, release and verification tooling and its tests |
experimental/licenses, THIRD_PARTY_NOTICES.md | Dependency licenses shipped with a build |
The Vue app itself lives in mnema-talk;
CI checks it out at mnema-talk/ and embeds the signed bundle. Read the
server's SECURITY.md
before relying on any end-to-end claim. Licensed under the
AGPL-3.0.
Checks
cargo test --locked --manifest-path Cargo.toml
cargo clippy --locked --manifest-path Cargo.toml --all-targets -- -D warnings
cargo test --locked --manifest-path experimental/app/Cargo.toml --features shell,web-client,custom-protocol
cargo clippy --locked --manifest-path experimental/app/Cargo.toml --features shell,web-client,custom-protocol --all-targets -- -D warnings
node --test scripts/*.test.mjs
node scripts/check-limits.mjs
The first two commands build only the gaming logic of src/. The host and the
page tests (experimental/app/page-tests) run in the Shared desktop client DEV
builds and Desktop checks workflows. The small go.mod is only a module
boundary preventing a parent Go module from scanning npm Go fixtures.
Size and complexity limits
The same numbers as the server: production files up to 400 lines, test files up
to 800 (a Rust #[cfg(test)] module counts as a test file of its own), functions
up to 80 lines and cognitive complexity 15. scripts/check-limits.mjs checks the
file sizes, ESLint (linux/eslint.config.ts) checks TypeScript and clippy checks
Rust. Files and functions that were over the limit when it was introduced are
listed in scripts/limits-allowlist.txt and linux/eslint-suppressions.json;
those lists only shrink (an entry that is no longer needed fails the check).
Never add to them or raise a limit: split the code by responsibility.
Libraries and locked Rust dependency inventory: THIRD_PARTY_NOTICES.md.
The app icons are generated from the project's existing web/public/favicon.svg.
Distribution evidence
node --test scripts/*.test.mjs tests the license inventory checker.
node experimental/scripts/collect-licenses.mjs --check (with
mnema-talk checked out at mnema-talk/
and npm ci run in mnema-talk/web) verifies the notices in
experimental/licenses against the locked dependency graph of the host and the
web app's production packages. Distribute that directory, the notice file and
the root LICENSE beside a development binary. Checksums are not publisher
signatures.
The Rust advisory scan (cargo deny, deny.toml) is scoped to the shipped
Tauri targets, Windows and macOS. The published Linux client is Electron and is not in that graph. The
Linux-only GTK3 crates (gtk, glib 0.18, proc-macro-error) stay out of it;
the Tauri host on Linux is not built. Details:
doc/security-review-1.2.md.