Contributing

How to contribute to Rift Panel — development setup, project structure, code style, and the pull request workflow.

Development Setup

Before you can build and run Rift Panel locally, you need the following prerequisites installed on your system:

Prerequisites

Requirement	Minimum Version	Notes
Node.js	18+	Required for the React frontend build toolchain
Rust	Stable (latest)	Required for the Tauri backend. Install via `rustup`
Platform build tools	Varies	Windows: Visual Studio C++ Build Tools. macOS: Xcode Command Line Tools. Linux: `build-essential`, `libwebkit2gtk-4.1-dev`, `libssl-dev`, `libayatana-appindicator3-dev`

Getting Started

Clone the repository and install dependencies:

cd rift-panel
npm install

Start the development server with hot-reload:

npx tauri dev

This launches both the Vite dev server for the React frontend and the Tauri backend simultaneously. Changes to frontend code trigger instant hot module replacement. Changes to Rust code trigger a backend recompile (which takes a few seconds on the first build, but is incremental afterwards).

Running npx tauri dev gives you hot-reload for both the frontend and backend. The frontend reloads instantly on save, while Rust changes trigger a fast incremental recompile. This is the recommended workflow for day-to-day development.

Project Structure

The repository is organized into two main areas — the React frontend and the Rust backend — with shared configuration at the root.

Directory	Contents
`src/`	React frontend — components, hooks, state management, styles, and entry point
`src/components/`	UI components — panels, terminal wrappers, session dialogs, settings, sidebar, and tooling integrations
`src/lib/`	Utility modules — IPC wrappers, state persistence, schema migrations, and shared helpers
`src-tauri/`	Rust backend — Tauri application, command handlers, PTY management, and Cargo configuration
`src-tauri/src/`	Rust source files — `main.rs` (entry point), `commands.rs` (IPC handlers), PTY modules
`public/`	Static assets served by the frontend

Making Changes

Rift Panel follows a standard fork-and-pull-request workflow:

Fork the repository — Create a fork and clone it locally.
Create a branch — Branch from main with a descriptive name. Use prefixes like feat/, fix/, or refactor/ to indicate the type of change.
```
git checkout -b feat/my-new-feature
```
Make your changes — Write code, add tests if applicable, and verify everything works by running npx tauri dev.
Commit — Write clear, concise commit messages. Each commit should represent a single logical change.
```
git commit -m "Add panel drag-and-drop reordering"
```
Push and open a pull request — Push your branch to your fork and open a PR against main. Describe what your change does, why it is needed, and how to test it.

Code Style

Maintaining a consistent code style across the project makes the codebase easier to read and review. Follow these guidelines:

TypeScript strict mode — The frontend uses TypeScript with strict mode enabled. All new code must pass npx tsc --noEmit without errors. Avoid using any types; prefer explicit interfaces and type aliases.
Scoped CSS — Component styles use scoped CSS blocks within single-file components. Styles should reference CSS custom properties from the design token system (defined in main.css) rather than hard-coded color values.
No Tailwind utilities in components — While Tailwind is available in the project, component-level styling should use scoped CSS and design tokens, not Tailwind utility classes. This keeps component styles explicit and consistent with the existing codebase.
Rust formatting — Backend code should be formatted with cargo fmt and pass cargo clippy without warnings. Use Rust's standard error handling patterns with Result and ? propagation.

Reporting Issues

Found a bug or have a feature request? When reporting a bug, include:

Steps to reproduce — A clear sequence of actions that triggers the bug. The more specific, the better.
Expected behavior — What you expected to happen.
Actual behavior — What actually happened, including any error messages or unexpected output.
Environment — Your operating system, Rift Panel version, and any relevant system configuration (shell, Node.js version, Rust version).

If you are reporting a crash, check the Tauri webview developer console (Ctrl+Shift+I) and the Rust backend logs for error messages. Including these in your issue report helps significantly with diagnosis.