ZYNC — Real-Time Collaboration Desktop Application

A modern, cross-platform desktop application for real-time team collaboration.

Features • Installation • Development • Building • Architecture • Contributing • License

Overview

ZYNC is a real-time collaboration platform built for development teams who need seamless communication, project management, and code collaboration tools in one unified interface. The desktop application extends the web platform with native operating system integrations that enhance productivity and user experience.

Why a Desktop Application?

While the ZYNC web application provides full functionality through any modern browser, the desktop application offers several advantages that justify its existence as a standalone native application:

System Tray Integration: ZYNC runs in the background and provides instant access through the system tray icon, allowing users to stay connected without keeping a browser tab open.
Native Notifications: Desktop notifications are delivered through the operating system's native notification system, ensuring they are visible even when the application is minimized or in the background.
Keyboard Shortcuts: Global keyboard shortcuts allow users to quickly access ZYNC features from anywhere on their desktop, regardless of which application is currently in focus.
Auto-Updates: The application automatically checks for and installs updates, ensuring users always have the latest features and security patches without manual intervention.
Offline Capabilities: Certain features continue to work offline, with automatic synchronization when connectivity is restored.
Deep Linking: Custom protocol handlers (zync://) allow other applications to deep-link directly into specific ZYNC features or conversations.
Window Management: Multi-window support with persistent window state (position, size, maximization state) across application restarts.

Features

Core Features

Feature	Description
Dashboard	Centralized overview of all team activities, recent projects, and quick actions
Workspace	Kanban-style project boards with drag-and-drop task management
Calendar	Team calendar with meeting scheduling and deadline tracking
Notes	Real-time collaborative note editor with rich text formatting
Tasks	Comprehensive task management with assignments, due dates, and priorities
Chat	Real-time messaging with @mentions, file attachments, and message reactions
Meet	Video conferencing integration for team meetings and pair programming
Activity Log	Detailed activity tracking with time logging and contribution graphs

Desktop-Specific Features

Feature	Description
System Tray	Background operation with quick-access context menu
Auto-Updates	Automatic application updates with progress notifications
Native Notifications	OS-level notifications for messages, mentions, and reminders
Global Shortcuts	System-wide keyboard shortcuts for quick access
Deep Linking	`zync://` protocol support for external integrations
Window Persistence	Remembers window position, size, and state across sessions
Splash Screen	Branded loading screen during application startup
Crash Reporting	Automatic crash report collection and submission
Settings Page	Native settings interface with download links for all platforms

Collaboration Features

Real-Time Presence: See who is online, away, or offline in real-time
Collaborative Editing: Multiple users can edit the same document simultaneously
Screen Sharing: Share your screen during video calls for pair programming
File Sharing: Drag-and-drop file sharing with preview support
@Mentions: Tag team members in conversations and notes for notifications
Activity Graphs: Visual representation of team activity and contributions
Team Management: Create and manage teams with role-based access control

Developer Features

GitHub Integration: Connect GitHub accounts for repository management
Git Commands: Built-in Git command reference and quick actions
Repository Selector: Browse and manage connected repositories
Task-Git Sync: Link tasks to Git branches, commits, and pull requests
Contribution Graph: GitHub-style contribution visualization

System Requirements

Minimum Requirements

Component	Requirement
CPU	1.6 GHz dual-core processor
RAM	2 GB
Storage	500 MB available disk space
Display	1280 x 720 resolution
Network	Broadband internet connection (for real-time features)

Recommended Specifications

Component	Specification
CPU	2.0 GHz quad-core processor or better
RAM	4 GB or more
Storage	1 GB available disk space
Display	1920 x 1080 resolution or higher
Network	High-speed internet connection (10 Mbps+)
Camera	Webcam (for video conferencing features)
Microphone	Built-in or external microphone (for audio features)

Supported Operating Systems

Platform	Versions	Architecture	Installer
Windows	Windows 10, Windows 11	x64, arm64	NSIS (.exe)
macOS	macOS 10.15 (Catalina) and later	x64, arm64 (Apple Silicon)	DMG (.dmg)
Linux	Ubuntu 18.04+, Fedora 32+, Debian 10+	x64	AppImage (.AppImage)

Installation

Download Pre-built Binaries

Visit the Releases page to download the latest version for your platform.

Windows Installation

Download ZYNC-Setup-x.x.x.exe from the Releases page
Run the installer
Choose the installation directory (default: C:\Program Files\ZYNC)
Select whether to create desktop and Start Menu shortcuts
Click "Install" to complete the installation
Launch ZYNC from the desktop shortcut or Start Menu

Silent Installation (for system administrators):

# Install silently with default options
ZYNC-Setup-x.x.x.exe /S

# Install to a custom directory
ZYNC-Setup-x.x.x.exe /S /D=C:\CustomPath\ZYNC

macOS Installation

Download ZYNC-x.x.x.dmg from the Releases page
Open the DMG file
Drag ZYNC.app to the Applications folder
Launch ZYNC from the Applications folder or Spotlight search
If prompted about the application being from an unidentified developer:
- Go to System Preferences → Security & Privacy
- Click "Open Anyway"

Installation via Homebrew (coming soon):

# Install via Homebrew Cask
brew install --cask zync

Linux Installation

Download ZYNC-x.x.x.AppImage from the Releases page
Make the file executable:
```
chmod +x ZYNC-x.x.x.AppImage
```
Run the application:
```
./ZYNC-x.x.x.AppImage
```

Desktop Integration:

# Install AppImageLauncher for desktop integration
# Then double-click the AppImage to integrate it into your desktop
sudo apt install appimagelauncher

Development

Prerequisites

Tool	Version	Purpose
Node.js	18.x or later	JavaScript runtime for building and running
npm	9.x or later	Package manager for installing dependencies
Git	2.x or later	Version control for source code management
Python	3.x	Required by some native Node.js modules
Visual Studio Build Tools	2019+ (Windows only)	Required for compiling native modules on Windows
Xcode Command Line Tools	(macOS only)	Required for compiling native modules on macOS

Setting Up the Development Environment

# Step 1: Clone the repository from GitHub
# This creates a local copy of the source code on your machine
git clone https://github.com/ChitkulLakshya/Zync.git

# Step 2: Navigate into the project directory
# All subsequent commands should be run from this directory
cd Zync

# Step 3: Install all project dependencies
# This installs both production and development dependencies
# defined in package.json. The installation may take several
# minutes depending on your internet connection speed.
npm install

# Step 4: Create a local environment file
# Copy the example environment file and fill in your own values
# for the Firebase configuration and API URLs
cp .env.example .env

# Step 5: Verify the installation
# Run the TypeScript compiler to check for any type errors
npx tsc --noEmit

Running in Development Mode

# Start the application in development mode
# This runs both the Vite dev server and Electron concurrently
npm run electron:dev

# Alternatively, run just the web application without Electron
# Useful for frontend development and testing
npm run dev

# Run with verbose logging enabled
# This provides detailed output for debugging purposes
ELECTRON_ENABLE_LOGGING=1 npm run electron:dev

Project Structure

Zync/
├── .github/                    # GitHub-specific configuration files
│   ├── workflows/              # GitHub Actions CI/CD workflows
│   │   ├── electron-build.yml  # Automated build pipeline for all platforms
│   │   ├── release.yml         # Automated release pipeline
│   │   └── codeql.yml          # Security analysis workflow
│   └── dependabot.yml          # Automated dependency update configuration
│
├── build/                      # Build resources for electron-builder
│   └── icons/                  # Application icons for all platforms
│       ├── icon.ico            # Windows icon (256x256, multi-size ICO)
│       ├── icon.icns           # macOS icon (512x512, Apple Icon format)
│       └── icon.png            # Linux icon (512x512, PNG format)
│
├── docs/                       # Developer documentation
│   ├── ARCHITECTURE.md         # System architecture documentation
│   ├── DEVELOPMENT.md          # Development setup guide
│   └── DEPLOYMENT.md           # Deployment and release guide
│
├── electron/                   # Electron main process source code
│   ├── assets/                 # Static assets for the Electron app
│   │   ├── icons.ts            # Base64-encoded SVG icons
│   │   ├── platform-logos.ts   # Base64-encoded platform logos
│   │   ├── sounds.ts           # Base64-encoded notification sounds
│   │   └── splash.ts           # Splash screen resources
│   │
│   ├── config/                 # Configuration modules
│   │   ├── constants.ts        # Application-wide constants
│   │   ├── csp.ts              # Content Security Policy configuration
│   │   ├── defaults.ts         # Default configuration values
│   │   ├── permissions.ts      # Permission handler configuration
│   │   └── security.ts         # Security policy configuration
│   │
│   ├── interfaces/             # TypeScript interface definitions
│   │   ├── config.ts           # Configuration interfaces
│   │   ├── ipc.ts              # IPC message interfaces
│   │   ├── services.ts         # Service interfaces
│   │   ├── settings.ts         # Settings interfaces
│   │   ├── updater.ts          # Auto-updater interfaces
│   │   └── window.ts           # Window management interfaces
│   │
│   ├── main/                   # Main process modules
│   │   ├── crash-reporter.ts   # Crash reporting service
│   │   ├── deep-link.ts        # Deep linking handler
│   │   ├── ipc-handlers.ts     # IPC event handlers
│   │   ├── menu.ts             # Application menu builder
│   │   ├── tray.ts             # System tray manager
│   │   └── window-state.ts     # Window state persistence
│   │
│   ├── preload/                # Preload script modules
│   │   └── types.d.ts          # Type definitions for exposed APIs
│   │
│   ├── renderer/               # Renderer process helpers
│   │
│   ├── services/               # Background services
│   │   └── auto-updater.ts     # Auto-update service
│   │
│   ├── settings/               # Settings window
│   │   ├── about.html          # About page
│   │   ├── about.js            # About page logic
│   │   ├── animations.css      # Settings page animations
│   │   ├── index.html          # Settings page layout
│   │   ├── platform-utils.js   # Platform detection utilities
│   │   ├── renderer.js         # Settings page renderer
│   │   ├── shortcuts.html      # Keyboard shortcuts reference
│   │   ├── shortcuts.js        # Shortcuts page logic
│   │   ├── store.ts            # Settings persistence
│   │   └── style.css           # Settings page styles
│   │
│   ├── splash/                 # Splash screen
│   │   ├── index.html          # Splash screen layout
│   │   └── style.css           # Splash screen styles
│   │
│   ├── types/                  # Global type definitions
│   │   ├── electron-env.d.ts   # Electron environment types
│   │   └── global.d.ts         # Global type augmentations
│   │
│   ├── utils/                  # Utility modules
│   │   ├── clipboard.ts        # Clipboard utilities
│   │   ├── fs-helpers.ts       # File system helpers
│   │   ├── logger.ts           # Logging utility
│   │   ├── network.ts          # Network connectivity checker
│   │   ├── notifications.ts    # Notification manager
│   │   ├── paths.ts            # Platform-specific path resolver
│   │   └── screenshot.ts       # Screenshot utility
│   │
│   ├── main.ts                 # Main process entry point
│   └── preload.ts              # Preload script entry point
│
├── src/                        # Frontend (renderer process) source code
│   ├── api/                    # API client modules
│   ├── components/             # React components
│   │   ├── dashboard/          # Dashboard-specific components
│   │   ├── kibo-ui/            # Custom UI components
│   │   ├── landing/            # Landing page components
│   │   ├── layout/             # Layout components (navbar, etc.)
│   │   ├── notes/              # Note editor components
│   │   ├── ui/                 # Shadcn/UI component library
│   │   ├── views/              # View components (pages within dashboard)
│   │   └── workspace/          # Workspace components
│   ├── hooks/                  # Custom React hooks
│   ├── lib/                    # Library utilities
│   ├── pages/                  # Top-level page components
│   ├── services/               # Frontend service modules
│   ├── App.tsx                 # Root application component
│   ├── index.css               # Global styles
│   ├── main.tsx                # Application entry point
│   └── vite-env.d.ts           # Vite type definitions
│
├── tests/                      # Test files
│   ├── main/                   # Main process tests
│   └── utils/                  # Utility tests
│
├── backend/                    # Backend server source code
│
├── .editorconfig               # Editor configuration for consistent formatting
├── .eslintrc.cjs               # ESLint configuration
├── .gitignore                  # Git ignore rules
├── .prettierrc.json            # Prettier formatting configuration
├── CHANGELOG.md                # Version changelog
├── CODE_OF_CONDUCT.md          # Community code of conduct
├── CONTRIBUTING.md             # Contribution guidelines
├── LICENSE                     # MIT License
├── SECURITY.md                 # Security policy
├── electron-builder.yml        # Electron Builder configuration
├── index.html                  # Application entry HTML
├── package.json                # Project metadata and dependencies
├── package-lock.json           # Locked dependency versions
├── tsconfig.json               # Root TypeScript configuration
├── tsconfig.app.json           # Frontend TypeScript configuration
├── tsconfig.electron.json      # Electron TypeScript configuration
├── tsconfig.node.json          # Node.js TypeScript configuration
└── vite.config.ts              # Vite build configuration

Environment Variables

Variable	Description	Required	Default
`VITE_API_URL`	Backend API base URL	Yes	`http://localhost:5000`
`VITE_FIREBASE_API_KEY`	Firebase API key	Yes	—
`VITE_FIREBASE_AUTH_DOMAIN`	Firebase auth domain	Yes	—
`VITE_FIREBASE_PROJECT_ID`	Firebase project ID	Yes	—
`VITE_FIREBASE_STORAGE_BUCKET`	Firebase storage bucket	Yes	—
`VITE_FIREBASE_MESSAGING_SENDER_ID`	Firebase messaging sender ID	Yes	—
`VITE_FIREBASE_APP_ID`	Firebase app ID	Yes	—
`VITE_FIREBASE_MEASUREMENT_ID`	Firebase measurement ID	No	—
`ELECTRON_ENABLE_LOGGING`	Enable verbose Electron logging	No	`false`

Building

Building for Windows

# Build the Windows installer (.exe)
# This creates an NSIS installer in the dist_electron directory
npm run electron:build -- --win

# Build without code signing (for development/testing)
CSC_IDENTITY_AUTO_DISCOVERY=false npm run electron:build -- --win

Building for macOS

# Build the macOS DMG installer
# Note: Must be run on a macOS machine
npm run electron:build -- --mac

# Build for both Intel and Apple Silicon
npm run electron:build -- --mac --x64 --arm64

Building for Linux

# Build the Linux AppImage
npm run electron:build -- --linux

# Build for specific architectures
npm run electron:build -- --linux --x64

Build Configuration

The build process is configured through electron-builder.yml. Key settings:

Output Directory: dist_electron/ — All build artifacts are placed here
Build Resources: build/ — Icons and other build-time resources
File Patterns: Only electron/**/* and package.json are included
Windows: NSIS installer with optional installation directory selection
macOS: DMG with drag-to-Applications layout
Linux: AppImage for maximum compatibility

Architecture

High-Level Architecture

┌─────────────────────────────────────────────────────────────────┐
│                     ZYNC Desktop Application                      │
│                                                                   │
│  ┌──────────────────────┐          ┌──────────────────────────┐  │
│  │    Main Process       │          │   Renderer Process        │  │
│  │   (electron/main.ts)  │   IPC    │  (Vite + React App)       │  │
│  │                       │◄────────►│                           │  │
│  │  • Window Management  │          │  • Dashboard              │  │
│  │  • System Tray        │          │  • Workspace              │  │
│  │  • Auto-Updates       │          │  • Chat                   │  │
│  │  • Native Menus       │          │  • Notes                  │  │
│  │  • Deep Linking       │          │  • Calendar               │  │
│  │  • Notifications      │          │  • Tasks                  │  │
│  │  • File System        │          │  • Settings               │  │
│  │                       │          │  • Meet                   │  │
│  └──────────────────────┘          └──────────────────────────┘  │
│           │                                    │                   │
│           │ Preload Script                     │ Web APIs          │
│           │ (electron/preload.ts)              │                   │
│           │                                    │                   │
│           ▼                                    ▼                   │
│  ┌──────────────────────┐          ┌──────────────────────────┐  │
│  │   Node.js APIs        │          │   Backend Server          │  │
│  │  (File System, OS)    │          │  (Express + MongoDB)      │  │
│  └──────────────────────┘          └──────────────────────────┘  │
└─────────────────────────────────────────────────────────────────┘

Main Process

The main process (electron/main.ts) is responsible for:

Application Lifecycle: Handling ready, window-all-closed, and activate events to manage the application lifecycle correctly across all platforms.
Window Management: Creating and managing the main application window and secondary windows (settings, about). Window state (position, size, maximized state) is persisted across sessions.
System Tray: Creating a system tray icon with a context menu that allows users to show/hide the window, check for updates, and quit.
Menu System: Building the application menu bar with keyboard shortcuts for common actions.
Auto-Updates: Checking for updates on startup and periodically, downloading updates in the background, and notifying users when updates are ready to install.
IPC Handlers: Handling messages from the renderer process for actions that require Node.js or native OS access.

Renderer Process

The renderer process loads the ZYNC web application, which is built with:

React — UI component library
Vite — Build tool and development server
React Router — Client-side routing
TanStack Query — Data fetching and caching
Firebase — Authentication and real-time database
Tailwind CSS — Utility-first CSS framework
Shadcn/UI — Component library built on Radix UI primitives

Preload Scripts

The preload script (electron/preload.ts) provides a secure bridge between the main and renderer processes by exposing specific APIs through contextBridge:

electron.downloadPlatform(platform) — Request platform-specific downloads
electron.openSettings() — Open the native settings window
electron.on(channel, callback) — Listen for main process messages
versions.node() — Get Node.js version
versions.chrome() — Get Chrome version
versions.electron() — Get Electron version

IPC Communication

Communication between processes uses Electron's IPC module with strict channel whitelisting:

Channel	Direction	Purpose
`download-platform`	Renderer → Main	Request platform download
`open-settings`	Renderer → Main	Open settings window
`check-for-updates`	Renderer → Main	Trigger update check
`get-app-version`	Renderer → Main	Get application version
`fromMain`	Main → Renderer	Send messages to renderer

Security Model

Context Isolation: Enabled by default, preventing the renderer process from directly accessing Node.js APIs.
Node Integration: Disabled in the renderer process, requiring all Node.js access to go through the preload script.
Content Security Policy: Strict CSP headers prevent XSS attacks and unauthorized script execution.
Channel Whitelisting: Only pre-approved IPC channels are allowed, preventing arbitrary communication between processes.
Input Validation: All IPC messages are validated before processing to prevent injection attacks.
HTTPS Only: The application only loads content over HTTPS in production mode.

Configuration

Application Settings

The ZYNC desktop application can be configured through the Settings page, accessible from the application menu or by pressing Ctrl+, (Windows/Linux) or Cmd+, (macOS).

Available settings include:

Setting	Description	Default
Start on Login	Launch ZYNC when the system starts	Disabled
Minimize to Tray	Minimize to system tray instead of taskbar	Enabled
Auto-Update	Automatically download and install updates	Enabled
Notifications	Enable desktop notifications	Enabled
Theme	Application theme (Light, Dark, System)	System
Language	Application language	English

Keyboard Shortcuts

Shortcut	Action
`Ctrl/Cmd + N`	Create new note
`Ctrl/Cmd + ,`	Open settings
`Ctrl/Cmd + Q`	Quit application
`Ctrl/Cmd + R`	Reload application
`Ctrl/Cmd + Shift + I`	Open Developer Tools
`Ctrl/Cmd + +`	Zoom in
`Ctrl/Cmd + -`	Zoom out
`Ctrl/Cmd + 0`	Reset zoom
`F11`	Toggle fullscreen

Testing

Running Tests

# Run all tests
npm test

# Run tests with coverage report
npm run test:coverage

# Run only main process tests
npm test -- --testPathPattern=tests/main

# Run only utility tests
npm test -- --testPathPattern=tests/utils

# Run tests in watch mode during development
npm run test:watch

Troubleshooting

Common Issues

Application won't start

# Clear the application cache and try again
# Windows
rmdir /s /q "%APPDATA%\ZYNC"

# macOS
rm -rf ~/Library/Application\ Support/ZYNC

# Linux
rm -rf ~/.config/ZYNC

Build fails on Windows

Ensure Visual Studio Build Tools are installed:

npm install --global windows-build-tools

Blank screen after launch

This usually indicates the web application URL is unreachable:

Check your internet connection
Verify the VITE_API_URL environment variable is set correctly
Try running npm run dev separately to verify the dev server works

Debug Mode

# Enable debug mode with verbose logging
ELECTRON_ENABLE_LOGGING=1 DEBUG=* npm run electron:dev

# Open DevTools automatically on startup
npm run electron:dev -- --inspect

Logging

Log files are stored in the following locations:

Platform	Log Location
Windows	`%APPDATA%\ZYNC\logs\`
macOS	`~/Library/Logs/ZYNC/`
Linux	`~/.config/ZYNC/logs/`

Contributing

We welcome contributions from the community! Please read our Contributing Guidelines before submitting a pull request.

Quick Start for Contributors

Fork the repository
Create a feature branch: git checkout -b feature/my-feature
Make your changes and add tests
Commit using conventional commits: git commit -m "feat: add new feature"
Push to your fork: git push origin feature/my-feature
Open a Pull Request

License

This project is licensed under the MIT License — see the LICENSE file for details.

Acknowledgments

Electron — Framework for cross-platform desktop apps
React — UI component library
Vite — Next-generation frontend build tool
Firebase — Backend-as-a-Service platform
Tailwind CSS — Utility-first CSS framework
Shadcn/UI — Beautifully designed components
electron-builder — Complete solution for packaging Electron apps

Made with ❤️ by the ZYNC Team

Name		Name	Last commit message	Last commit date
Latest commit History 517 Commits
.github		.github
assets		assets
backend		backend
build/icons_bak		build/icons_bak
config		config
dist-electron/electron		dist-electron/electron
docs		docs
electron		electron
infrastructure		infrastructure
public		public
scripts		scripts
src		src
tests		tests
.editorconfig		.editorconfig
.eslintignore		.eslintignore
.eslintrc.cjs		.eslintrc.cjs
.gitignore		.gitignore
.prettierignore		.prettierignore
.prettierrc		.prettierrc
.prettierrc.json		.prettierrc.json
ARCHITECTURE.md		ARCHITECTURE.md
ARCHITECTURE_ANALYSIS.md		ARCHITECTURE_ANALYSIS.md
AUDIT.md		AUDIT.md
BACKEND_OVERVIEW.md		BACKEND_OVERVIEW.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
DEPENDENCY_REPORT.md		DEPENDENCY_REPORT.md
DRIBBBLE_SETUP.md		DRIBBBLE_SETUP.md
LICENSE		LICENSE
OAUTH_EXPLANATION.md		OAUTH_EXPLANATION.md
Overhaul.md		Overhaul.md
PRIVACY_POLICY.md		PRIVACY_POLICY.md
PROJECT_AUDIT.md		PROJECT_AUDIT.md
README.md		README.md
SECURITY.md		SECURITY.md
bun.lockb		bun.lockb
coderabbit.yaml		coderabbit.yaml
components.json		components.json
cors.json		cors.json
electron-builder.yml		electron-builder.yml
error_log.txt		error_log.txt
eslint.config.js		eslint.config.js
index.html		index.html
overhaul_prompts.md		overhaul_prompts.md
package-lock.json		package-lock.json
package.json		package.json
postcss.config.js		postcss.config.js
tailwind.config.ts		tailwind.config.ts
test.html		test.html
tsconfig.app.json		tsconfig.app.json
tsconfig.electron.json		tsconfig.electron.json
tsconfig.eslint.json		tsconfig.eslint.json
tsconfig.json		tsconfig.json
tsconfig.node.json		tsconfig.node.json
vercel.json		vercel.json
vite.config.ts		vite.config.ts

License

prem22k/Zync

Folders and files

Latest commit

History

Repository files navigation

ZYNC — Real-Time Collaboration Desktop Application

Table of Contents

Overview

Why a Desktop Application?

Features

Core Features

Desktop-Specific Features

Collaboration Features

Developer Features

System Requirements

Minimum Requirements

Recommended Specifications

Supported Operating Systems

Installation

Download Pre-built Binaries

Windows Installation

macOS Installation

Linux Installation

Development

Prerequisites

Setting Up the Development Environment

Running in Development Mode

Project Structure

Environment Variables

Building

Building for Windows

Building for macOS

Building for Linux

Build Configuration

Architecture

High-Level Architecture

Main Process

Renderer Process

Preload Scripts

IPC Communication

Security Model

Configuration

Application Settings

Keyboard Shortcuts

Testing

Running Tests

Troubleshooting

Common Issues

Application won't start

Build fails on Windows

Blank screen after launch

Debug Mode

Logging

Contributing

Quick Start for Contributors

License

Acknowledgments

About

Resources

License

Code of conduct

Contributing

Security policy

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors 6

Uh oh!

Languages

Packages