The open‑source, fully customisable VCS client.

OpenVCS is a new and upcoming cross‑platform version control client built with Tauri, Rust, and a modern TypeScript + Vite frontend. It aims to be the all‑in‑one solution for version control: clean, fast, and extensible. Features are actively being explored and are not yet finalised.

Scope note: The first main release focuses on Git to keep the scope tight. The long‑term vision is to support all major VCS systems through a backend/plugin architecture (e.g., Mercurial, SVN, Perforce, Fossil, etc.).

Quick Install (AppImage)

OpenVCS provides a convenience script that fetches the latest AppImage, stores it at ~/Applications/openvcs.AppImage, and creates a desktop entry so you can launch it from your app menu. Run:

curl -fsSL https://raw.githubusercontent.com/Jordonbc/OpenVCS/stable/install.sh | bash

The script targets Linux, leaves existing configuration untouched, and can be re-run to pull the newest release. To install a pre-release, pass the flag through to the script: curl -fsSL https://raw.githubusercontent.com/Jordonbc/OpenVCS/stable/install.sh | bash -s -- --prerelease. To uninstall: curl -fsSL https://raw.githubusercontent.com/Jordonbc/OpenVCS/stable/install.sh | bash -s -- --uninstall. Swap stable for dev in the URL if you want the bleeding-edge installer.

---

Key Goals

• 🧩 Fully customisable - themes, layout, and extensibility at the core.
• 🗂 Multi‑VCS architecture - designed to support many backends beyond Git.
• ⚡ Lightweight & fast - native shell via Tauri + Rust.
• 🧰 Developer‑first UX - frictionless flows for common VCS tasks.
• 🧱 Local‑first - avoids heavyweight runtimes and keeps resource use low.

Platform Targets

• 🐧 Linux‑first (primary target)
• 🪟 Windows builds supported
• 🍏 macOS not currently planned (community interest welcome)

Features (Planned & In‑Progress)

• 🔗 Git backend (initial) with common operations (clone, add, commit, branch, push/pull, fetch, stash).
• 🔌 Backend abstraction to enable additional VCS (Mercurial/SVN/Perforce/Fossil) in future releases.
• 🎨 Theming (planned): custom themes and a potential Theme Store.
• 🧩 Plugins (planned): plugin API with a potential Plugin Store.
• 🖼 Modern UI focused on clarity and speed; keyboard‑first workflows.
• 📁 Multi‑repo quality‑of‑life features (recents, quick switch, project workspaces).

This roadmap is exploratory; priorities may shift as we collect community feedback.

---

Repository Structure

.
├── Backend/              # Rust + Tauri backend (native logic, app entry)
├── Frontend/             # TypeScript + Vite frontend (UI layer)
├── crates/               # Rust crates for modular OpenVCS components
│   ├── openvcs-core      # Core traits and abstractions
│   ├── openvcs-git       # Git implementation
│   └── openvcs-git-libgit2 # Alternative Git backend (libgit2)
├── Cargo.toml            # Workspace manifest
├── LICENSE
└── README.md

---

Getting Started

Prerequisites

• Rust (latest stable recommended)
• Cargo (ships with Rust)
• Node.js (for the frontend toolchain)
• npm (package manager)
• Git installation (system Git is currently required)

Installation

For the automated installer, see Quick Install (AppImage).

Manual AppImage download

Prefer a portable setup? Download the latest AppImage from the GitHub releases page (e.g. https://github.com/Jordonbc/OpenVCS/releases/latest), make it executable, and run it directly:

chmod +x OpenVCS-*.AppImage
./OpenVCS-*.AppImage

Store the AppImage wherever you like; no installation step is required.

Build from source

Clone the repository:

git clone https://github.com/Jordonbc/OpenVCS.git
cd openvcs

Install frontend dependencies:

cd Frontend
npm install

Run in development mode from the workspace root:

cargo tauri dev

Build a release binary:

cargo tauri build

Optional: Rust‑only build

If you want to verify the Rust workspace compiles independently (without running Tauri):

cargo build

---

Development Workflow

• Frontend: TypeScript + Vite for a fast iteration loop.
• Backend: Rust + Tauri commands for native operations.
• Crates: All modular logic (e.g., Git backend, core abstractions) lives under crates/.
• Bridge: Tauri invoke is used to call Rust from the UI; events are used for progress/streaming.

Design principles:

1. Separation of concerns - UI logic stays in the frontend; VCS logic lives in backend crates.
2. Backend abstraction - a trait‑driven interface to enable multiple VCS backends over time.
3. Extensibility - theming and plugin hooks are planned as part of the long‑term architecture, but will follow after the core VCS features are complete.

---

Contributing

OpenVCS is open source and community‑driven. Contributions of all kinds are welcome:

• Bug reports & feature proposals
• UX feedback and design mocks
• Backend adapters for other VCS
• Theme prototypes and early plugin experiments

See CONTRIBUTING.md (coming soon). Until then, feel free to open an issue or a discussion to propose changes.

Proposed Roadmap (High‑level)

• MVP: Stable Git workflows; Linux and Windows builds; core UI.
• Theming: Planned for later; will likely begin with simple theme packs (e.g. zip files in a directory) before exploring an initial gallery or store.
• Plugins: Planned for later; will likely begin as simple plugin bundles (e.g. zip files in a directory) before evolving toward a store with discovery UX.
• Multi‑VCS: Add at least one non‑Git backend to validate the abstraction.

---

Recommended IDE Setup

• Visual Studio Code
• Extensions:
  • Tauri
  • rust-analyzer
  • TypeScript ESLint

---

Project Status

OpenVCS is in early development. Features and APIs are not yet finalised and may change frequently. Feedback will directly shape the roadmap.

License

GPL-3.0

Screenshots / Demos

The UI is actively evolving as core features take shape. Below is a small preview of the current design (subject to change):

More screenshots and demos will be shared once the design stabilises and a reliable build is ready.