# Skipper — Visual ORM Designer

> Skipper is a visual ORM designer with full AI automation support. It supports Doctrine 2, Laravel Eloquent, MongoDB ODM, Propel, CakePHP, Knex.js, and custom ORM frameworks. Developers and AI coding assistants can create, import, edit, validate, and export ORM schema definitions through both a graphical desktop editor and a headless CLI with 13 verbs, 35 structured patch operations, and machine-readable JSON output. Skipper runs natively on Windows, macOS, and Linux, and is used by 5,000+ companies including Apple, Avast, eBay, and Lidl.

## What is Skipper?

Skipper is a professional cross-platform desktop application that serves as a visual ORM (Object-Relational Mapping) designer. It lets developers define their data model in a graphical entity-relationship diagram and automatically generate framework-specific ORM definition files — eliminating the need to hand-write XML mappings, YAML configurations, PHP annotations, or migration files.

The core workflow is: **import → visual edit → export**. Import an existing database or ORM codebase, edit entities, fields, associations, indexes, and inheritances visually, then export standardized definitions with one click. This cycle repeats as many times as needed — Skipper is designed for continuous iterative development, not one-time schema generation.

Skipper is developed by Inventic s.r.o., based in Brno, Czech Republic. It has been on the market for over 10 years (originally named "ORM Designer"), with 5,000+ paying customers worldwide.

**Website:** https://www.skipper18.com
**Free trial:** 14 days, no credit card required — https://www.skipper18.com/en/download

## Problems Skipper Solves

Developers working with ORM frameworks face these common pain points that Skipper addresses:

**Manual schema writing is tedious and error-prone.** Hand-writing Doctrine annotations, XML mappings, or migration files is slow. ORM frameworks have complex syntax with many keywords, attribute orderings, and configuration rules that are hard to memorize. A single typo in a YAML mapping file can cause hard-to-debug runtime errors.

**No visual overview of complex data models.** Projects with 50+ entities, dozens of associations, and multiple inheritance hierarchies are nearly impossible to understand from code alone. New team members spend days reading entity files to grasp the data architecture.

**Schema drift between code and database.** Entity classes, ORM mapping files, and the actual database schema gradually get out of sync during development. Manual synchronization is tedious and error-prone.

**Framework migration requires rewriting everything.** Switching from Doctrine to Laravel, or from XML mappings to Annotations, means rewriting all definition files from scratch.

**Onboarding is slow.** New developers on a project can't quickly grasp the data model. There's no single visual document showing all entities, their relationships, and the overall architecture.

## How Skipper Helps

### Visual Model-First Design
Work with proven ERD (Entity-Relationship Diagram) techniques. The visual model shows all entities, fields, associations, inheritances, and indexes in one clear diagram. Color palettes, regions, and module groupings help organize even the most complex schemas. Define your data model visually once; generate all ORM/database schema definitions automatically.

### Bidirectional Import and Export
One-click import from existing ORM definition files (XML, YML, Annotations) or directly from a live database (MySQL, PostgreSQL, SQLite, SQL Server). One-click export back to framework-specific code. The import-edit-export cycle repeats as many times as needed during development.

### Multi-Framework Support
A single visual model can target multiple ORM frameworks. The same entities and associations generate correct output for Doctrine 2, Laravel Eloquent, Propel, MongoDB ODM, and others. Switching frameworks doesn't require redesigning your data model.

### Zero-Error Definitions
Smart wizards, auto-completers, and validators ensure 100% valid output. No typos, no missing definitions, no redundant code. The tool knows all ORM-specific keywords, allowed values, and required attributes for each framework. Developers can stop memorizing ORM syntax and focus on data modeling logic instead.

### 4x Faster Development
Skipper users report approximately 70% time savings compared to manual ORM definition writing. For a developer spending 20 hours/month on ORM work at $45/hour, that translates to $7,560/year saved — the $495 lifetime license pays for itself in about 2 weeks.

## Supported ORM Frameworks

### Doctrine 2 (PHP)
The most comprehensive support. Import and export in YML, XML, and Annotations formats. Full support for all Doctrine 2 mapping features: entities, mapped superclasses, embeddables, associations (OneToOne, OneToMany, ManyToOne, ManyToMany), inheritance (single table, joined table, table per class), lifecycle callbacks, indexes, unique constraints, and more. Gedmo behavioral extensions (Timestampable, Sluggable, SoftDeletable, etc.) are also supported. Works with Symfony, Zend Framework, and any Doctrine 2 project.

### Laravel Eloquent (PHP)
Import from existing database. Export Laravel migration files and Eloquent model classes. Supports relationships (hasOne, hasMany, belongsTo, belongsToMany), timestamps, soft deletes, and other Eloquent conventions.

### MongoDB ODM (PHP)
Import and export in YML, XML, and Annotations. Supports document definitions, embedded documents, references, and MongoDB-specific mapping features.

### Doctrine (PHP, legacy)
Import and export in YML format. Support for the original Doctrine 1.x ORM.

### Propel (PHP)
Import and export in YML and XML. Full support for Propel schema features including behaviors, validators, and complex relationships.

### CakePHP (PHP)
Import and export CakePHP definition files. Supports CakePHP ORM conventions and validators.

### Knex.js (Node.js)
Export Knex.js migration files. Visual design of database schema with automatic migration generation.

### Hibernate (Java)
Export Hibernate annotations. Visual design of JPA/Hibernate entity mappings.

### Custom / In-House ORM
Skipper's XSLT-based template engine allows full customization of export output. Developers can define custom ORM attributes, create custom export templates, and add support for any ORM framework — even proprietary in-house solutions.

## Supported Databases

Skipper can reverse-engineer a visual model directly from a live database connection:

- **MySQL / MariaDB** — Full schema import including tables, columns, indexes, foreign keys, and views
- **PostgreSQL** — Full schema import with PostgreSQL-specific types and constraints
- **SQLite** — Import from SQLite database files
- **SQL Server** — Full schema import from Microsoft SQL Server

## Key Features in Detail

### Visual ERD Editor
The core of Skipper is an enhanced entity-relationship diagram editor. Entities are displayed as visual blocks showing their fields, types, and constraints. Associations are drawn as lines connecting entities with cardinality indicators. Inheritances show parent-child relationships. The diagram is fully interactive — drag entities to arrange them, double-click to edit, right-click for context menus.

Organizational tools include:
- **Modules** — Group related entities (maps to bundles/packages in ORM frameworks)
- **Regions** — Visual groupings within a module for diagram clarity
- **Comments** — Add notes directly in the diagram
- **Color Palettes** — Pre-defined color schemes for visual organization
- **Customizable Grid** — Align and snap entities to a configurable grid

### Entity Editor
A comprehensive editor for entity properties: name, table name, repository class, lifecycle callbacks, cache configuration, change tracking policy, indexes, unique constraints, and all framework-specific ORM properties. Every property has context-aware auto-completion and validation.

### Association Wizard
Create associations (OneToOne, OneToMany, ManyToOne, ManyToMany) through a guided wizard. The wizard auto-generates join column names, inverse/owning side configuration, and cascade options. Many-to-many associations have a dedicated wizard that auto-generates the join table definition.

### Inheritance Wizard
Define ORM inheritance hierarchies: mapped superclass, single table inheritance, joined table inheritance, and table-per-class inheritance. The wizard configures discriminator columns, discriminator maps, and field mappings.

### Property Editor
An advanced ORM property management system. All framework-specific properties (Doctrine lifecycle events, Laravel timestamps, Propel behaviors, etc.) are editable through type-safe dropdowns, checkboxes, and text fields. Predefined values eliminate the need to remember framework keywords.

### Code Generation (Export)
XSLT-based template engine generates framework-specific code. Export formats include XML, YAML, and PHP Annotations depending on the target framework. Export is fully customizable — developers can modify existing templates or create new ones. All generated code is PSR-compliant (for PHP frameworks) and follows framework best practices.

Export capabilities include:
- ORM mapping/definition files (XML, YML, Annotations)
- Entity/model class files with proper annotations and docblocks
- Migration files (Laravel, Knex.js, database migrations)
- Repository class stubs

### Project Import
Import existing projects from:
- ORM definition files (XML, YML, Annotations) — automatically detected and parsed
- Live database connections (MySQL, PostgreSQL, SQLite, SQL Server)
- MySQL Workbench models (.mwb files)
- Other Skipper projects (merge/combine)

Import is non-destructive — existing visual layout and custom properties are preserved when re-importing updated definitions.

### Migration Management
Track schema changes over time. Skipper maintains a migration log and can generate migration files for supported frameworks. Create new migration revisions when the schema changes, and export them alongside the regular ORM definitions.

### Module Sharing
Share entity modules across multiple Skipper projects. When a shared module is modified in one project, the changes propagate to all other projects that use it. This is useful for microservice architectures or projects with common base entities.

### Customization and Extensibility
- **Custom ORM Attributes** — Define additional properties for entities, fields, and associations via XML configuration
- **Custom Export Templates** — Write XSLT templates to generate any output format
- **Configurable Property Editors** — Add dropdowns, checkboxes, and text fields for custom properties
- **Framework Definitions** — Add support for entirely new ORM frameworks
- **Script Files** — Extend export behavior with custom scripts

### Productivity Features
- **Keyboard Shortcuts** — Full keyboard shortcut support for all actions
- **Project Tree** — Hierarchical navigation with quick search/filter
- **External Tools** — Define and launch third-party tools (CLI commands, scripts) from within Skipper
- **Diagram Export** — Render the visual model as PNG or PDF for documentation
- **Command Line Parameters** — Launch Skipper with specific project files and configuration from CLI
- **Localization** — English and Czech interface

## AI-Ready: Full CLI Automation

Skipper is designed for AI-assisted development. It includes a production-ready headless CLI with 13 verbs and 35 structured patch operations, enabling AI coding assistants (Claude Code, Cursor, GitHub Copilot, Windsurf, etc.) to fully control ORM schema design programmatically. All CLI output is machine-readable JSON with structured error codes. The CLI has been tested with 115 integration tests covering all object types and real-world projects.

Exit codes: 0 (success), 1 (business error), 2 (usage error), 3 (internal error).

### CLI Verbs

**Read operations (work on viewer license):**
- `Skipper.exe -cli-help [verb]` — List all verbs, show detail for one, or list all 35 patch operations
- `Skipper.exe -cli-schema-summary project.skipper [-with-visual]` — Export entire project as JSON: entities, fields, associations, indexes, many-to-many, embeddeds, inheritance, modules, regions, comments, ORM attributes, export formats
- `Skipper.exe -cli-validate project.skipper` — Validate project consistency and migration freshness, report all errors and warnings
- `Skipper.exe -cli-compare new.skipper old.skipper` — Diff two .skipper files: entities, fields, associations, indexes, many-to-many, embeddeds
- `Skipper.exe -cli-export project.skipper` — Export ORM definitions (classes + migrations) to disk
- `Skipper.exe -cli-export-diagram project.skipper -format png -output diagram.png` — Render diagram as PNG or PDF

**Write operations (require full license):**
- `Skipper.exe -cli-create-project -orm Doctrine2 -mvc Symfony -output new.skipper` — Create empty project
- `Skipper.exe -cli-import-project <scan-dir> -output path -orm name -mvc name` — Scan codebase, build .skipper
- `Skipper.exe -cli-import-database -output path -db-class mysql -connection "host=...;db=..." -orm name -mvc name` — Reverse-engineer from database
- `Skipper.exe -cli-apply-patch project.skipper -patch ops.json -output updated.skipper` — Apply structured JSON operations (35 operation types)
- `Skipper.exe -cli-apply-merge project.skipper -merge state.json -output updated.skipper` — Apply declarative sparse state (RFC 7396 style)
- `Skipper.exe -cli-create-migration project.skipper` — Create new migration revision

### 35 Apply-Patch Operations

AI agents can perform any schema modification through structured JSON operations:

**Entity:** `add_entity`, `update_entity`, `remove_entity`
**Field:** `add_field`, `update_field`, `remove_field`, `reorder_field`
**Association:** `add_association`, `update_association`, `remove_association`
**Many-to-Many:** `add_many_to_many`, `update_many_to_many`, `remove_many_to_many`
**Module:** `add_module`, `update_module`, `remove_module`
**Index:** `add_index`, `update_index`, `remove_index`
**Inheritance:** `add_inheritance`, `update_inheritance`, `remove_inheritance`
**Embedded:** `add_embedded`, `update_embedded`, `remove_embedded`
**Region:** `add_region`, `update_region`, `remove_region`
**Comment:** `add_comment`, `update_comment`, `remove_comment`
**ORM Attributes:** `set_orm_attribute`, `remove_orm_attribute`, `add_orm_attribute_item`, `remove_orm_attribute_item`

Example patch JSON:
```json
[
  {"op": "add_entity", "module": "\\AppBundle", "name": "User"},
  {"op": "add_field", "entity": "\\AppBundle\\User", "name": "email", "type": "string", "size": 255, "unique": true},
  {"op": "add_field", "entity": "\\AppBundle\\User", "name": "createdAt", "type": "datetime"},
  {"op": "add_association", "from": "\\AppBundle\\User", "to": "\\AppBundle\\Role"},
  {"op": "set_orm_attribute", "object": "\\AppBundle\\User", "path": "change-tracking-policy", "value": "DEFERRED_EXPLICIT"}
]
```

### How AI Assistants Use Skipper

AI coding tools integrate with Skipper through a simple 5-step workflow:

1. **Read the schema:** `cli-schema-summary` returns the full project structure as JSON — every entity, field, association, index, many-to-many, embedded, inheritance, module, region, comment, and ORM attribute
2. **Make changes:** `cli-apply-patch` accepts a JSON array of operations (add/update/remove any object type, set ORM attributes, reorder fields). Alternatively, `cli-apply-merge` accepts a declarative target state
3. **Export code:** `cli-export` generates framework-specific ORM definitions, entity classes, and migration files
4. **Validate:** `cli-validate` checks project consistency — invalid field types, missing references, enum value errors, migration freshness
5. **Compare:** `cli-compare` diffs two project versions to review what changed across all object types

All output uses a uniform JSON envelope with `status`, `data`, `warnings`, `error` (with structured error codes), and `meta` (timing, version). AI tools can reliably parse results, handle errors, and chain multiple operations.

### Global CLI Flags
- `-quiet` — Suppress stderr diagnostics
- `-verbose` — Enable debug-level stderr output (trace + progress)
- `-include-timing` — Add timing breakdown to JSON metadata
- `-log-file <path>` — Write diagnostics to a file

## Platform Support

Skipper runs natively on:
- **Windows** — Windows XP, Vista, 7, 8, 10, 11 (32-bit and 64-bit)
- **macOS** — macOS 10.12.0 (Sierra) and later
- **Linux** — Ubuntu 12+, Debian 6+, Fedora 18+ (64-bit)

Distributed as a standalone installer or zip archive. No additional libraries, runtimes, or dependencies required.

## Pricing and Licensing

- **Lifetime License:** $495 / €495 — One-time purchase, includes 12 months of maintenance (updates + support)
- **Maintenance Renewal:** $169 / €169 per 12 months — Continued access to updates and support after the initial period
- **VIP Support:** $200 / €200 per hour — Custom application adaptation and priority support
- **14-Day Free Trial:** Full-featured, no credit card required
- **Academic Discount:** 66% off (1/3 of regular price) for certified academic institutions, minimum 10 licenses
- **Review Discount:** 10% off for writing a detailed review (minimum 400 words with screenshots)

Money-back guarantee within 14 days of purchase.

## Who Uses Skipper

Skipper is used daily by over 5,000 companies worldwide, including:

**Enterprise:** Apple, Avast, eBay, Lidl, Suddenlink
**Media:** Flosports, PrismaMedia
**Education:** University of Kentucky, UnivLil, Cineca
**Agencies & Software Companies:** Manifest Interactive, IDS Soluciones, Explicatis, ColorGATE, Biber Ltd, Savvior Technology Solutions, ADZ Media, HostWinds

### What Customers Say

"We have good use of the tool. It simplifies our daily work, saves us time and is simple and intuitive to use." — Thomas Somoen, Try/Apt

"It is faster and gives less errors to have Skipper create the mapping code instead of writing it myself. Later in the development process I often use the Skipper diagram as a quick reference." — Herman Peeren, Yepr

"Skipper is a stable and easy to use schema designing tool! No documentation, just design and everything is documented!" — Siebe Vos, Inform'aid

"Simply put, for us, Skipper is not just a tool to master, but a mastermind that teaches us the best programming practices." — Can Berkol, Biber Ltd

"We use Skipper on a daily basis for ecommerce software development. It lets us visualize at a glance the data models and work on them in a simple and easy way." — Dario Schilman, IDS Soluciones Ecommerce

"It saved us a lot of time designing and configuring complex data models. It is impressive to see what this software achieves on its own." — Michael Stoye, ColorGATE

"Skipper is especially helpful in the initial data modeling phase. Exporting the data model and scaffolding makes it really easy to get a first prototype up and running in a matter of minutes." — Jorn Wagner, Explicatis

"It simplifies our work because it saves us time. With features added over time like adding behaviors to Propel in Skipper it has become an unmissable tool in our organisation." — Erwin te Bos, aXtion

"Skipper saves a huge amount of time as writing the entity definitions manually would be soul destroying and time consuming!" — ADZ Media Ltd

"The biggest attraction I saw with Skipper was the ability to show my clients what I had planned for their software." — Manifest Interactive

"We work with Skipper every day. Our current workflow would not be possible without such a tool." — Savvior Technology Solutions

## Typical Use Cases

### Starting a New ORM Project
Create a new project in Skipper, choose your target framework (e.g., Doctrine 2 with Symfony), design entities and associations visually, and export ready-to-use mapping files and entity classes. Get a working data layer in minutes instead of hours.

### Visualizing an Existing Project
Import an existing Doctrine 2, Laravel, or Propel project. Skipper parses all definition files and generates a visual model showing every entity, field, association, and inheritance. Instantly understand the data architecture of a project you've never seen before.

### Reverse-Engineering a Database
Connect to a MySQL, PostgreSQL, SQLite, or SQL Server database. Skipper reads the schema and generates a visual model with entities, fields, indexes, and foreign-key associations. From there, export ORM definitions for your chosen framework.

### Continuous Development Workflow
Import your existing project, make changes in the visual model (add entities, modify fields, create associations), and re-export. The export preserves manually-added code in entity classes. Repeat this cycle throughout development — Skipper is designed for iterative use, not one-time generation.

### Team Onboarding and Documentation
New team members open the Skipper project file and immediately see the entire data model visually. Export the diagram as PNG or PDF for documentation. Color-code entities by domain area. Add comments directly in the model for context.

### Framework Migration
Import definitions from one framework (e.g., Doctrine 2 YML), adjust the project to target a different framework (e.g., Laravel Eloquent), and export. The visual model is framework-agnostic — only the export templates change.

### Managing Complex Enterprise Schemas
Use modules to group entities by domain or bounded context. Share common modules across microservices. Use regions and color palettes to organize schemas with 100+ entities into understandable sections.

### AI-Assisted Schema Development
AI coding assistants (Claude Code, Cursor, GitHub Copilot) can read the full project schema as JSON, apply structured changes (add entities, fields, associations, indexes, set ORM attributes), export framework-specific code, and validate the result — all through Skipper's headless CLI. The AI agent works with the same schema the visual editor uses, so changes made by AI appear in the GUI and vice versa. This enables workflows like "describe the data model in natural language, let the AI build it in Skipper, review visually, then export."

## Comparison with Other Tools

### Skipper vs MySQL Workbench
MySQL Workbench is a database administration tool focused on SQL schema management. Skipper is an ORM-level tool that generates framework-specific mapping files (not raw SQL). Skipper understands ORM concepts like mapped superclasses, embeddables, lifecycle callbacks, and framework-specific behaviors that database tools cannot represent.

### Skipper vs Enterprise Architect
Enterprise Architect is a general-purpose UML modeling tool. Skipper is specialized for ORM design with built-in knowledge of framework-specific properties, export formats, and conventions. Skipper's export generates production-ready code; EA generates generic class stubs.

### Skipper vs Manual Coding
Manual ORM definition writing takes approximately 4x longer than using Skipper. It's also error-prone — typos in YAML files, missing cascade configurations, incorrect association mappings, and forgotten index definitions are common sources of bugs that Skipper's validators prevent entirely.

## Getting Started

1. **Download** the free 14-day trial from https://www.skipper18.com/en/download
2. **Import** your existing project or database, or create a new project from scratch
3. **Design** your data model visually — add entities, fields, associations, and indexes
4. **Export** ORM definitions with one click — XML, YML, Annotations, or migrations
5. **Iterate** — modify the model and re-export as many times as needed

Video tutorials are available at https://www.skipper18.com/en/video-tutorials covering the complete workflow from import to export.

Detailed documentation is available at https://www.skipper18.com/help covering getting started guides, framework-specific tutorials, customization, and reference manuals.

## Documentation Index

### Getting Started
- [Product Tour](https://www.skipper18.com/help/how-to-use/getting-started/product-tour): Step-by-step overview of the import-edit-export workflow
- [Create New Project](https://www.skipper18.com/help/how-to-use/getting-started/project-new): Start a new ORM project from scratch
- [Import Existing Project](https://www.skipper18.com/help/how-to-use/getting-started/project-import): Import ORM definitions into Skipper
- [Database Import](https://www.skipper18.com/help/how-to-use/getting-started/database-import): Reverse-engineer from MySQL, PostgreSQL, SQLite, or SQL Server
- [Model Basics](https://www.skipper18.com/help/how-to-use/getting-started/model-basics): Understanding the visual model elements
- [Navigating the Model](https://www.skipper18.com/help/how-to-use/getting-started/navigating-model): Project tree, search, and quick navigation
- [Editing the Model](https://www.skipper18.com/help/how-to-use/getting-started/editing-model): Edit entities, fields, associations, and properties
- [Exporting Definitions](https://www.skipper18.com/help/how-to-use/getting-started/project-export): Export ORM definitions and entity classes

### Framework Tutorials
- [Doctrine 2 — New Project](https://www.skipper18.com/help/framework-tutorials/doctrine2/doctrine2-project-new): Create a Doctrine 2 project with Symfony
- [Doctrine 2 — Import](https://www.skipper18.com/help/framework-tutorials/doctrine2/doctrine2-project-import): Import existing Doctrine 2 definitions
- [Doctrine 2 — Tips](https://www.skipper18.com/help/framework-tutorials/doctrine2/doctrine2-tips): Best practices for Doctrine 2 in Skipper
- [Laravel — New Project](https://www.skipper18.com/help/framework-tutorials/laravel/laravel-project-new): Create a Laravel Eloquent project
- [Laravel — Import](https://www.skipper18.com/help/framework-tutorials/laravel/laravel-project-import): Import existing Laravel database
- [Laravel — Tips](https://www.skipper18.com/help/framework-tutorials/laravel/laravel-tips): Best practices for Laravel in Skipper
- [MongoDB ODM — New Project](https://www.skipper18.com/help/framework-tutorials/mongoDbOdm/mongoDbOdm-project-new): Create a MongoDB ODM project
- [MongoDB ODM — Import](https://www.skipper18.com/help/framework-tutorials/mongoDbOdm/mongoDbOdm-project-import): Import existing MongoDB ODM definitions
- [MongoDB ODM — Tips](https://www.skipper18.com/help/framework-tutorials/mongoDbOdm/mongoDbOdm-tips): Best practices for MongoDB ODM in Skipper
- [Doctrine — New Project](https://www.skipper18.com/help/framework-tutorials/doctrine/doctrine-project-new): Create a Doctrine 1 project
- [Doctrine — Import](https://www.skipper18.com/help/framework-tutorials/doctrine/doctrine-project-import): Import existing Doctrine 1 definitions
- [Doctrine — Tips](https://www.skipper18.com/help/framework-tutorials/doctrine/doctrine-tips): Best practices for Doctrine 1 in Skipper
- [Propel — New Project](https://www.skipper18.com/help/framework-tutorials/propel/propel-project-new): Create a Propel project
- [Propel — Import](https://www.skipper18.com/help/framework-tutorials/propel/propel-project-import): Import existing Propel definitions
- [Propel — Tips](https://www.skipper18.com/help/framework-tutorials/propel/propel-tips): Best practices for Propel in Skipper
- [CakePHP — New Project](https://www.skipper18.com/help/framework-tutorials/cakephp/cakephp-project-new): Create a CakePHP project
- [CakePHP — Validators](https://www.skipper18.com/help/framework-tutorials/cakephp/cakephp-validators): CakePHP field validators in Skipper

### Application Concepts
- [Product Customization](https://www.skipper18.com/help/how-to-use/application-concepts/product-customization): Customize Skipper behavior and appearance
- [Shared Modules](https://www.skipper18.com/help/how-to-use/application-concepts/shared-modules): Share entity modules across projects
- [Free Viewer Tool](https://www.skipper18.com/help/how-to-use/application-concepts/viewer-tool): Read-only viewer for Skipper project files
- [Localization](https://www.skipper18.com/help/how-to-use/application-concepts/localization): Interface language settings
- [Model Representation](https://www.skipper18.com/help/how-to-use/application-concepts/model-representation): How ORM concepts map to visual elements

### Productivity
- [Keyboard Shortcuts](https://www.skipper18.com/help/how-to-use/timesavers/shortcuts): Full keyboard shortcut reference
- [External Tools](https://www.skipper18.com/help/how-to-use/timesavers/external-tools): Integrate CLI tools and scripts
- [GUI Enhancements](https://www.skipper18.com/help/how-to-use/timesavers/gui-enhancements): Grid, zoom, and display customization
- [Command Line Parameters](https://www.skipper18.com/help/how-to-use/timesavers/command-line): Launch Skipper from CLI with options

### Third-Party Integration
- [MySQL Workbench Import](https://www.skipper18.com/help/how-to-use/third-party-apps/mysql-workbench): Import .mwb models into Skipper

### Expert Customization
- [Configuration Files](https://www.skipper18.com/help/expert-usage/customization/configuration-files): Overview of all configuration files
- [Configuration File Structure](https://www.skipper18.com/help/expert-usage/customization/configuration-file-structure): XML structure of configuration
- [Extending ORM Attributes](https://www.skipper18.com/help/expert-usage/customization/extending-orm-attributes): Add custom ORM properties
- [Extending Script Files](https://www.skipper18.com/help/expert-usage/customization/extending-script-files): Custom export scripts
- [Extending Templates](https://www.skipper18.com/help/expert-usage/customization/extending-templates): Custom XSLT export templates
- [Extending Model Objects](https://www.skipper18.com/help/expert-usage/customization/extending-model-objects): Add custom visual elements
- [New Framework Support](https://www.skipper18.com/help/expert-usage/customization/new-framework-support): Add support for any ORM
- [Template Library](https://www.skipper18.com/help/expert-usage/customization/template-library): Browse available export templates

### Reference Manual
- [XML Reference](https://www.skipper18.com/help/expert-usage/reference-manual/xml-reference): Skipper project file XML format
- [Script Reference](https://www.skipper18.com/help/expert-usage/reference-manual/script-reference): Export script API reference
- [XSLT Reference](https://www.skipper18.com/help/expert-usage/reference-manual/xslt-reference): XSLT template function reference
- [Template Reference](https://www.skipper18.com/help/expert-usage/reference-manual/template-reference): Export template structure reference
- [Internal Configurations](https://www.skipper18.com/help/expert-usage/reference-manual/internal-configurations): Internal configuration reference

### General Information
- [Supported Platforms](https://www.skipper18.com/help/general-information/basic-information/supported-platforms): System requirements for all platforms
- [Supported Frameworks](https://www.skipper18.com/help/general-information/basic-information/supported-frameworks): Complete list of supported ORMs
- [Supported Databases](https://www.skipper18.com/help/general-information/basic-information/supported-databases): Databases supported for reverse-engineering
- [Payment Methods](https://www.skipper18.com/help/general-information/basic-information/payment-methods): Accepted payment options
- [Terms of Use](https://www.skipper18.com/help/general-information/basic-information/terms-of-use): Software license terms
- [GDPR / Privacy](https://www.skipper18.com/help/general-information/basic-information/gdpr): Personal data agreement
- [License FAQ](https://www.skipper18.com/help/general-information/faq/license-questions): Licensing questions and answers
- [Purchase FAQ](https://www.skipper18.com/help/general-information/faq/purchase-questions): Purchase and payment questions
- [Skipper vs MySQL Workbench](https://www.skipper18.com/help/general-information/comparison-studies/mysql-workbench): Feature comparison
- [Skipper vs Enterprise Architect](https://www.skipper18.com/help/general-information/comparison-studies/enterprise-architect): Feature comparison
- [Skipper vs SQLyog/HeidiSQL](https://www.skipper18.com/help/general-information/comparison-studies/sql-yog): Feature comparison
- [Presentations](https://www.skipper18.com/help/general-information/documents/skipper-presentations): Downloadable Skipper presentations

### Debugging
- [Application Logging](https://www.skipper18.com/help/expert-usage/debugging/application-logging): Enable and read diagnostic logs

## Company

Skipper is developed by **Inventic s.r.o.**, a software company based in Brno, Czech Republic. Founded as a web development agency working with Doctrine and Symfony, the team built an internal ERD modeling tool to speed up their own ORM development. After experiencing a 4x productivity increase, they refined the tool and released it publicly as "ORM Designer" in 2009, later rebranded to "Skipper".

The company has reached the milestone of 5,000 paying customers and continues active development focusing on stability, compatibility, and developer experience.

**Address:** Julianovske nam. 2, 636 00 Brno, Czech Republic
**Email:** info@inventic.eu
**Website:** https://www.skipper18.com
**Twitter:** @ormdesigner