Where to Find Openship's Source Code: A Complete Guide to the GitHub Repository

Openship's complete source code is available in the public GitHub monorepo at https://github.com/oblien/openship.

Openship is an open-source, self-hostable deployment platform built with TypeScript and organized as a pnpm workspace monorepo. You can explore, clone, and contribute to the project directly on GitHub, where the codebase is split between core packages under packages/ and user-facing applications in apps/.

Repository Location and Quick Start

The primary repository lives at oblien/openship on GitHub. To obtain the source code locally, clone the repository using standard Git commands:

git clone https://github.com/oblien/openship.git
cd openship

This downloads the entire monorepo, including the core engine, database layer, web dashboard, desktop client, and CLI tooling.

Monorepo Architecture Overview

Openship follows a monorepo structure managed by pnpm workspaces. The codebase is logically divided into two main directories:

• packages/ – Shared libraries and core business logic (configuration parsing, database models, CLI helpers)
• apps/ – End-user applications (React-based dashboard, Electron desktop client)

This architecture allows the team to maintain strict separation between the deployment engine and the various interfaces that consume it, while sharing TypeScript types and utilities across the workspace.

Core Components and Key Source Files

Understanding the file layout helps you navigate the repository effectively. Here are the critical source files that define Openship's functionality.

Core Engine

The engine handles configuration parsing, update resolution, and runtime orchestration. Key files include:

• packages/core/src/openship-config/schema.ts – Defines the openship.json schema and validation logic
• packages/core/src/updates/resolve.ts – Contains platform-specific binary selection logic for updates

Database Layer

Openship uses PostgreSQL with Drizzle ORM for data persistence. The typed models live in:

• packages/db/src/schema/project.ts – Defines the Project schema and relationships
• packages/db/src/repos/project.repo.ts – Provides CRUD helpers and repository patterns for project management

Web Dashboard

The React-based single-page application manages deployments, domains, and resources:

• apps/dashboard/src/utils/deployment.ts – Orchestrates deployments triggered from the UI
• apps/dashboard/src/utils/authWindow.ts – Handles authentication flows and OAuth windows

Desktop Client

The Electron/Node-based desktop application runs the control plane locally:

• apps/web/src/lib/llms.ts – Integrates LLM-powered helpers used by the desktop UI for intelligent deployment assistance

CLI and Onboarding

The openship CLI and installation scripts power project scaffolding and local development:

• packages/onboarding/src/flow.ts – Implements the interactive onboarding wizard
• scripts/install.sh – The one-liner installer script (curl … | sh) that bootstraps the CLI

Running Openship from Source

Once you have cloned the repository, you can build and run the platform locally.

Development Setup

The project requires Bun for dependency management and building:

# Install dependencies

bun install

# Build the CLI from source

bun run build

# Start a self-hosted instance in bare mode (no Docker)

./bin/openship up --bare

Deploying a Sample Project

Use the locally built CLI to initialize and deploy projects:

# Inside a Node.js project directory

openship init          # creates an openship.json linking the repo

openship deploy        # builds & deploys the app (Docker or bare)

Docker Compose Deployment

For containerized deployments without building the CLI:

git clone https://github.com/oblien/openship.git
cd openship
cp .env.example .env   # edit .env as needed

docker compose -f docker/docker-compose.yml up -d

The docker/docker-compose.yml file provides a ready-to-run stack including the database, API, and dashboard services.

Summary

• Openship's source code is hosted publicly at github.com/oblien/openship under an open-source license
• The repository uses a pnpm workspace monorepo structure with packages/ for shared code and apps/ for applications
• Key entry points include packages/core/src/openship-config/schema.ts for configuration and apps/dashboard/src/utils/deployment.ts for UI logic
• You can run the platform locally using Bun for development or Docker Compose for production-like deployments
• The scripts/install.sh provides a quick one-line installation method for end users

Frequently Asked Questions

Is Openship completely open source?

Yes, Openship is fully open source and self-hostable. The entire codebase, including the core engine, dashboard, and CLI, is available in the public GitHub repository without proprietary restrictions, allowing you to inspect, modify, and deploy the platform on your own infrastructure.

What programming language is Openship written in?

Openship is written primarily in TypeScript. The project uses Node.js for the backend services, React for the web dashboard, and Electron for the desktop client, with all components sharing type definitions through the monorepo workspace configuration.

How do I contribute to Openship development?

To contribute, fork the repository at github.com/oblien/openship, create a feature branch, and submit a pull request. The codebase follows standard TypeScript conventions, and the monorepo structure in pnpm-workspace.yaml makes it easy to work across multiple packages while maintaining type safety and shared dependencies.

Can I run Openship without installing the CLI globally?

Yes, you can run Openship directly from the source without a global CLI installation. Use the docker/docker-compose.yml file to start the complete stack, or run ./bin/openship directly from the built source directory after executing bun run build in the cloned repository.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}