Codion Desktop
Application Framework

🖥️ Desktop First

When web deployment isn't required, desktop applications can provide responsive interfaces without browser constraints.

Native Desktop Advantages
• Keyboard navigation throughout with plenty of shortcuts
• System integration with file dialogs, clipboard, and desktop features
• True multitasking without browser tab limitations
• Lower memory usage compared to web applications
• Offline capability with local data and no network dependencies

Desktop UI Components
Tables, forms, and controls that handle large datasets efficiently. Context menus, drag-and-drop, focus management, and accessibility features that work across platforms.

Modern Themes
Include ~50 FlatLAF Look and Feels. Users can dynamically switch between Material themes (Darker, Oceanic, Night Owl), developer favorites (Dracula, One Dark, Gruvbox), or nature-inspired themes (Aurora Borealis, Sakura) without restarting (View → Select Look & Feel).

// Include the 6 core Flat Look and Feels
<dependency>
    <groupId>is.codion</groupId>
    <artifactId>codion-plugin-flatlaf</artifactId>
</dependency>

// Include ~50 IntelliJ theme based Flat Look and Feels
<dependency>
    <groupId>is.codion</groupId>
    <artifactId>codion-plugin-flatlaf-intellij-themes</artifactId>
</dependency>

Learn more about desktop applications →

🔒 Type Safe

Every aspect of Codion is compile-time checked. No string-based column references, no runtime surprises. Foreign keys are first-class citizens with automatic loading.

// Compile-time safety everywhere
Entity country = connection.selectSingle(Country.CODE.equalTo("USA"));
String capitalName = country.get(Country.CAPITAL_FK).get(City.NAME);

// Query results are type-checked at compile time
List<String> artistNames = connection.select(Artist.NAME, Artist.ID.in(1, 2));

// Generic column definitions with type safety
Column<List<String>> TAGS = TYPE.column("tags", new TypeReference<>() {});
Column<Location> COORDINATES = TYPE.column("location", Location.class);

// Conditions enforce correct attribute types
Condition lowRated = Track.RATING.lessThanOrEqualTo(4);
Condition expensive = Track.UNITPRICE.greaterThan(BigDecimal.ONE);

🔄 Observable by Design

Everything in Codion is observable. UI components automatically update when data changes. No manual synchronization, no event bus complexity. Just declare relationships and watch them work.

// Traditional approach - manual synchronization
textField.getDocument().addDocumentListener(new DocumentListener() {
    public void changedUpdate(DocumentEvent e) { updateFilter(); }
    public void removeUpdate(DocumentEvent e) { updateFilter(); }  
    public void insertUpdate(DocumentEvent e) { updateFilter(); }
});
button.setEnabled(false);  // Remember to update this everywhere!

// Codion approach - synchronous observable binding
Value<String> filter = Value.nullable();
State canSubmit = State.and(hasData, isValid);

JTextField filterField = Components.stringField()
    .link(filter)
    .hint("Filter...")
    .build();
    
JButton submitButton = Components.button()
    .action(submitAction)
    .enabled(canSubmit)  // Updates automatically and synchronously!
    .build();

Explore observable patterns (synchronous & debuggable) →

📉 Reduces Complexity

Adding ONE detail table causes 61-109% code explosions in other frameworks. That's just basic CRUD - for business-grade features (sortable columns, keyboard navigation, export, validation indicators), other frameworks need 10-15x more code.

// Basic master-detail
React + Node.js:  515 lines
Spring Boot:      355 lines 
Codion:           143 lines (with enterprise features included)

// For feature parity with Codion's defaults:
React + Node.js:  ~1,915 lines (+1,400 for table features)
Spring Boot:      ~1,355 lines (+1,000 for UI features)
Codion:           143 lines (no additional code needed)

View the complexity comparison →

⚔️ Battle tested

Codion has powered 50+ production applications over 20 years across scientific and government institutions, including critical infrastructure systems.

Learn about Codion's development approach →

🪶 Lightweight

Codion is built on Java Standard Edition - Swing, JDBC, and RMI. No third-party application servers or complex deployment scenarios.

Resource Efficiency
Codion applications typically use fewer resources than Electron-based counterparts:

// Typical resource usage comparison:
Electron app:     400MB+ RAM, 150MB+ disk
Codion app:       40-80MB RAM, 15MB disk

// CPU efficiency:
Electron: Constant background activity
Codion: Near-zero when idle

🤖 AI/LLM Ready

Codion's parameterized builder APIs enable code generation. Every method takes explicit parameters, making it suitable for AI-assisted development.

// LLM-friendly APIs
Components.stringField()
    .link(nameValue)
    .columns(20)
    .upperCase(true)
    .maximumLength(20)
    .action(insertAction)
    .horizontalAlignment(CENTER)
    .selectAllOnFocusGained(true)
    .transferFocusOnEnter(true);

Learn about code generation capabilities →

🏗️ Domain-Driven Design

Your business domain becomes executable, type-safe code. Define entities once with rich metadata, and Codion generates all CRUD operations, validations, and UI components automatically.

// Define your domain - this is all you need!
interface Customer {
    EntityType TYPE = DOMAIN.entityType("store.customer");
    
    Column<String> NAME = TYPE.stringColumn("name");
    Column<String> EMAIL = TYPE.stringColumn("email");
    Column<BigDecimal> CREDIT_LIMIT = TYPE.bigDecimalColumn("credit_limit");
}

// This definition provides:
// ✓ Type-safe CRUD operations
// ✓ Form validation and UI components  
// ✓ Search and filter capabilities
// ✓ Foreign key navigation

// Use it everywhere with compile-time safety:
Entity.Key customerKey = connection.insert(
    entities.entity(Customer.TYPE)
        .with(Customer.NAME, "John Doe")
        .with(Customer.EMAIL, "john@example.com")
        .with(Customer.CREDIT_LIMIT, new BigDecimal(10_000))
        .build());

Explore domain modeling →

🚀 Rapid Development With Joy

Minimal boilerplate and configuration. From domain model to working CRUD application in hours. Clean APIs with IDE support and compile-time safety.

// Domain definitions for a couple of tables ~100 lines
// Initial application and UI setup ~150 lines
// Run application and start testing