J2G Logo

J2G

Jenkins to GitLab CI Migration Tool

A desktop application that automates Jenkins-to-GitLab CI/CD migration — connects to your GitLab instance, finds Jenkinsfiles in repos, and converts them to production-ready .gitlab-ci.yml.

macOS · Windows · Linux
Electron Desktop App
Works Offline

What is J2G?

A desktop application that automates Jenkins-to-GitLab CI/CD migration — connects to your GitLab instance, finds Jenkinsfiles in repos, and converts them to production-ready .gitlab-ci.yml.

41
IPC Handlers
Full-featured backend with dedicated handlers for scan, convert, migrate, validate, export, and more
100+
Jenkins Patterns
Recognizes declarative & scripted pipelines, shared libraries, complex expressions
6
License Tiers
From Free (3 pipelines) to Unlimited — scales with team size and project complexity
3
Platforms
Native desktop builds for macOS (arm64/x64), Windows (x64/arm64), Linux (x64/arm64)
🔍

Scan & Explore
Connect to GitLab, scan projects for Jenkinsfiles, browse pipeline structures, explore with syntax highlighting.
📊

Analyze & Report
Deep analysis of pipeline complexity, step distribution, shared library usage, and migration readiness scoring.
⚡

Convert & Validate
One-click conversion with GitLab CI lint validation. Side-by-side diff view of Jenkins vs GitLab syntax.

See J2G in Action

A visual tour of the J2G desktop app — from scanning your GitLab projects and analysing pipeline complexity, to converting Jenkinsfiles into production-ready .gitlab-ci.yml. Click any screenshot to open the full-size viewer — use the ‹ › buttons or the arrow keys to navigate, press Esc to close.

How It Works

A streamlined 5-step pipeline — from connecting to GitLab to having production-ready CI/CD configuration. Works with a single project or thousands.

🔗
Connect
GitLab URL + token
On-prem or cloud
→
🔍
Scan
Find Jenkinsfiles in repos
Select projects to scan
→
📊
Analyze
Complexity scoring
Pattern detection
→
⚙️
Convert
Jenkinsfile → .gitlab-ci.yml
Lint validation
→
🚀
Migrate
Push .gitlab-ci.yml back
Create merge request
🔄 Flexible Workflow
Work with a single project or scan your entire GitLab instance. Convert one-by-one or batch hundreds — with progress tracking and cancel.
📋 Export Reports
Generate Markdown and PDF reports — migration summaries, complexity analysis, and team progress tracking.
🧩 Pattern Detection
Identify reusable Jenkins patterns across pipelines and extract GitLab CI/CD components automatically.

Conversion at a Glance

J2G translates Jenkins pipeline constructs into their GitLab CI/CD equivalents — not a 1:1 copy but an intelligent mapping.

⚡ Pipeline Structure
  • pipeline｛｝ → top-level .gitlab-ci.yml
  • stages｛｝ → stages: keyword
  • stage(‘X’)｛｝ → named job under stage
  • steps｛｝ → script: block
  • parallel｛｝ → parallel: matrix jobs
  • agent any → tags: runner tags
  • agent ｛ docker ｝ → image: directive
  • agent ｛ label ｝ → tags: runner mapping
🔧 Build Steps & Logic
  • sh/bat → script: commands
  • withEnv → variables: block
  • withCredentials → CI/CD variables reference
  • tool ‘maven’ → image: maven container
  • timeout → timeout: keyword
  • retry → retry: keyword
  • input → when: manual
  • catchError → allow_failure:
📦 Advanced Features
  • post｛ always ｝ → after_script:
  • post｛ success/failure ｝ → rules: conditions
  • when｛ branch ｝ → rules: if $CI_COMMIT_BRANCH
  • when｛ expression ｝ → rules: if expression
  • cron triggers → schedules: pipeline
  • archiveArtifacts → artifacts: paths:
  • stash/unstash → artifacts + dependencies
  • shared libraries → include: templates

Key Features

Everything you need for a successful Jenkins-to-GitLab migration — built into a single desktop application.

🔍

Smart Scanning
Scans GitLab projects for Jenkinsfiles — select specific projects or scan all. Multi-branch scanning (up to 20 branches) for Enterprise tiers.
📊

Deep Analysis
Pipeline complexity scoring, step distribution charts, shared library detection, and migration readiness assessment.
⚡

Single & Batch Convert
Convert one pipeline at a time or all at once. Progress tracking with per-pipeline status and cancel support.
✅

CI Lint Validation
Validate converted YAML against GitLab’s CI lint API — catch syntax and semantic errors before committing.
🚀

Direct Migration
Push .gitlab-ci.yml to a new branch and create a merge request — for a single project or in batch. Review before merging.
🧩

Pattern Detection
Identify common Jenkins patterns across pipelines. Extract reusable GitLab CI/CD component scaffolds.
🗺️

Variable Mapping
Map Jenkins credentials and env variables to GitLab CI/CD variables — automated configuration transfer.
🏷️

Runner Tag Mapping
Map Jenkins agent labels to GitLab Runner tags — ensure pipelines run on the right infrastructure.
📋

Export Reports
Generate Markdown and PDF migration reports. Share analysis results, track progress, document decisions.

Security & Privacy

No AI, no cloud, no telemetry. J2G is a deterministic, rule-based desktop application — your code stays on your machine.

💻 J2G Desktop
All processing local
No AI — rule-based only
← Reads Jenkinsfiles
→ Pushes .gitlab-ci.yml
HTTPS / GitLab REST API v4
🦊 GitLab
Your instance
On-prem / cloud
J2G connects only to your GitLab instance. Jenkinsfiles are read from GitLab repos — no Jenkins connection needed. The only calls beyond your infrastructure: license lockout time verification (public HTTPS time APIs, read-only). No data is sent to AI services, analytics, or any third party.
🚫 No AI — Deterministic Processing
  • Zero AI/ML components — no LLMs, no neural networks, no inference
  • All conversion uses deterministic regex + AST pattern matching
  • No data sent to OpenAI, Google, or any AI service
  • Same input always produces same output — fully reproducible
  • Only 1 runtime dependency: js-yaml (YAML parser)
🔒 Local-Only Processing
  • Parsing, analysis, and conversion happen entirely on your machine
  • Jenkinsfiles never leave your filesystem or network
  • Converted YAML stored in memory until you explicitly save or push
  • Works fully offline (only GitLab API calls need network)
  • Air-gapped compatible — lockout timer falls back to local clock offline
📡 Zero Telemetry
  • No analytics libraries (no Google Analytics, Mixpanel, Sentry, etc.)
  • No usage tracking, crash reporting, or behaviour monitoring
  • No sendBeacon(), no tracking pixels, no event logging
  • Only outbound beyond GitLab: lockout time verification (public HTTPS, read-only)
  • No third-party SDKs of any kind bundled in the application
💾 RAM-Only Data Model
  • In-memory Chromium partition — no persistent browser storage
  • Cookies, LocalStorage, SessionStorage, IndexedDB all disabled
  • purgePersistedData() runs on every startup — cleans leftovers
  • Tokens held in process memory only — never written to disk
  • Only disk writes: license data + anti-tamper marker + optional file-cache

Security Deep Dive

Electron hardening, license protection, and compliance — designed for enterprise security review.

🛡️ Electron Hardening
  • ▸contextIsolation: true, nodeIntegration: false
  • ▸Preload bridge: 43 named IPC methods — no raw ipcRenderer access
  • ▸CSP: default-src 'self'; script-src 'self'
  • ▸DevTools blocked in production (4 mechanisms)
  • ▸Remote debug disabled, --inspect blocked, V8: --jitless
  • ▸External URLs restricted to http/https; execSync scoped to app git only
🔐 Electron Fuses (compile-time)
  • ▸RunAsNode: false — binary cannot be used as Node.js
  • ▸EnableNodeOptionsEnvironmentVariable: false
  • ▸EnableNodeCliInspectArguments: false
  • ▸Fuses baked into binary — cannot be changed at runtime
  • ▸macOS: hardened runtime + entitlements + re-signed post-fuse
  • ▸Strongest Electron hardening available today
🔑 License Protection
  • ▸Ed25519 signed keys — offline cryptographic verification
  • ▸Machine fingerprint binding (platform + arch + CPU + memory hash)
  • ▸Shadow marker + foreign-machine detection — permanently blocks shared keys
  • ▸HMAC-SHA256 integrity checksums — tampered data resets to Free tier
  • ▸Per-key usage tracking + GitLab instance binding across activations
  • ▸Brute-force lockout with NTP verification + anti-clock-rollback detection
  • ▸V1 key format auto-sunset — forces migration to v2 signed keys
🔗 API & Network Security
  • ▸HTTPS-only with session certificate pinning (MITM detection)
  • ▸Tokens in PRIVATE-TOKEN headers — never in URLs or logs
  • ▸Automatic TLS fallback for self-signed / corporate certificates
  • ▸DELETE/PUT/PATCH hard-blocked; only 5 POST endpoints whitelisted
  • ▸Rate limiting (50ms min) + exponential backoff on 429/503
  • ▸Per-operation timeouts (30s API, 45s file, 60s commit) + AbortController
✅ Compliance & Audit
  • ▸No PII collection or processing by J2G
  • ▸Only outbound: your GitLab instance + public time APIs (read-only, no data sent)
  • ▸No persistent cookies or browser-level sessions
  • ▸All write actions user-initiated — startup checks are read-only
  • ▸Single production dependency (js-yaml) — minimal supply chain
  • ▸Deterministic output — auditable, testable, reproducible
🚨 Failure & Recovery
  • ▸One-click cancel aborts all in-flight API requests
  • ▸Connection test validates access before full scan
  • ▸No automatic retries on auth failures (401/403)
  • ▸Graceful degradation on network/timeout errors
  • ▸Deactivate license instantly — resets to Free tier
  • ▸Clear error messages with actionable next steps

What J2G Does NOT Do

Setting clear expectations — J2G is a migration accelerator, not a magic wand. Understanding the boundaries helps plan your migration.

🚫

Not a GitLab Replacement
J2G is a migration tool — it does not run pipelines, host repos, or replace GitLab. It connects to your existing GitLab instance to read Jenkinsfiles and push converted YAML.
🚫

No 100% Automatic Conversion
Complex scripted pipelines, custom plugins, and Groovy logic may need manual review. J2G handles 80–90% automatically and flags the rest.
🚫

No Plugin Behavior Migration
J2G detects 65+ Jenkins plugins and maps them to GitLab equivalents automatically — but cannot replicate plugin-specific logic. Review mapped suggestions and configure GitLab integrations manually.
🚫

No Source Code Migration
J2G migrates CI/CD configuration only. Repository code, branches, and history migration is a separate process (use GitLab’s project import).
🚫

No Credential Transfer
Secrets and credentials are not copied between systems. J2G maps variable names and references — you must set the actual values in GitLab CI/CD settings.
🚫

No Runtime Testing
J2G validates YAML syntax via GitLab’s lint API, but does not execute the converted pipeline. Run your first pipeline manually to verify end-to-end.

Technical Specifications

Built with modern web technologies — a single codebase producing native desktop applications for all major platforms.

⚙️ Runtime & Framework
  • ▸Electron 41 (Chromium + Node.js)
  • ▸Pure JavaScript — no TypeScript, no build step
  • ▸Single main.js backend (6,500+ lines)
  • ▸Single app.js frontend (10,700+ lines)
  • ▸Context-isolated IPC (preload bridge)
  • ▸Hardened runtime on macOS
📦 Build & Distribution
  • ▸electron-builder for packaging
  • ▸macOS: DMG installers (arm64 + x64)
  • ▸Windows: NSIS installers (universal, x64, arm64)
  • ▸Linux: AppImage (x64) + .deb (amd64)
  • ▸10 build artifacts per release (7 binaries + SHA256 manifest + GPG signature + pubkey)
  • ▸Jenkins CI/CD release pipeline
🧪 Testing
  • ▸Custom test runner (zero dependencies)
  • ▸23 test suites, 330+ test cases
  • ▸Playwright E2E tests (5 phases)
  • ▸Real GitLab instance integration tests
  • ▸Mock-based unit tests (nock, fake-timers)
  • ▸Anti-abuse and edge case suites
📄 Jenkinsfile Parsing
  • ▸Declarative + scripted pipeline support
  • ▸Regex + AST rule-based pattern matching
  • ▸Shared library detection and mapping
  • ▸Groovy expression handling
  • ▸100+ recognized Jenkins constructs
  • ▸Deterministic — same input, same output
🦊 GitLab Integration
  • ▸REST API v4 with personal access token
  • ▸Project browsing, search, and selection
  • ▸Jenkinsfile discovery in repo tree
  • ▸Branch creation + commit push + MR
  • ▸CI lint API validation
  • ▸TLS fallback for self-hosted instances
🔐 Licensing System
  • ▸v2 key format with tier encoding
  • ▸Machine fingerprint binding
  • ▸Shadow marker anti-tampering
  • ▸Per-key usage tracking across activations
  • ▸Feature gate system (11 gated features)
  • ▸Graceful v1 → v2 key migration

Summary

J2G turns a weeks-long migration project into a streamlined, repeatable process.

🎯 Who It’s For
Enterprises of any size — from startups piloting a single pipeline to global platform teams running hundreds of CI/CD workflows. DevOps engineers, SRE leads, and platform architects use J2G to standardise migrations, enforce review gates, and cut risk. Start with one project or roll out across the whole organisation.
⚡ Time Savings
Manual migration: 30–60 minutes per pipeline (read Jenkinsfile, learn GitLab syntax, write YAML, test). With J2G: seconds per pipeline, including validation and merge request creation.
📊 Migration Insight
Complexity scoring and pattern detection give you a clear picture of migration effort before you start. Export reports to plan sprints, track progress, and report to stakeholders.
🔒 Zero Risk
Nothing touches your production pipelines. All conversion is read-only. Migration creates new branches with merge requests — review before merging. Roll back by closing the MR.
Start with 3 free conversions — no registration, no credit card.
Paid tiers are a one-time purchase — 1 year for Starter / Business / Enterprise / Enterprise+, lifetime for Unlim. No subscription, no auto-renewal.

Get in Touch

License Tiers & Pricing

Starter, Business, Enterprise, Enterprise+ — one-time purchase, valid for 1 year from the invoice date. After expiry the app stays installed and reverts to Free tier. Renew only if you need more conversions.

Unlim ($9,999) — lifetime licence. “Lifetime” means the economic life of the J2G product line — as long as we continue to publish and support J2G. No renewal needed, ever.

No subscription, no auto-renewal, no credit card on file. Free tier has no time limit.

Licences are purchased by request
Online checkout is on the roadmap — for now every order is handled personally. Tell us which tier you need via the contact form, and we typically reply within one business day with an invoice and activation key.
We stay in touch after the purchase. Questions, feedback, and feature requests directly shape how J2G evolves — if something isn’t working as you expect, we want to hear about it.

See the prices
3
Free
$0
25
Starter
$199 · 1 year
250
Business
$999 · 1 year
1,000
Enterprise
$2,499 · 1 year
5,000
Enterprise+
$4,999 · 1 year
∞
Unlim
$9,999 lifetime
Feature Free Starter Business Enterprise Enterprise+ Unlim
Price Free $199 $999 $2,499 $4,999 $9,999
Validity Unlimited 1 year 1 year 1 year 1 year Lifetime
Pipelines 3 25 250 1,000 5,000 Unlimited
Analyze Limit 6/scan 50/scan 500/scan 2,000/scan 10,000/scan Unlimited
Scan & Explore ✓ ✓ ✓ ✓ ✓ ✓
CI Lint Validation — ✓ ✓ ✓ ✓ ✓
Export Reports — ✓ ✓ ✓ ✓ ✓
Migrate to GitLab — — ✓ ✓ ✓ ✓
Patterns & Components — — ✓ ✓ ✓ ✓
Batch Convert — — ✓ ✓ ✓ ✓
Batch Migrate — — — ✓ ✓ ✓
Multi-Branch Scanning — — — 20/project Unlimited Unlimited
Variable & Runner Mapping — — — ✓ ✓ ✓
Multi-Instance (5 GitLab URLs) — — — — — ✓