100% native. Fast.

Full-stack Java.
Compiled to native.

Share Java from UI to server. Build native apps for phones and desktops, plus JavaScript for the web. Open source and free.

Create a Java project Try it in your browser View source on GitHub

GPLv2 with the Classpath Exception. Free for commercial use. No royalties.

Main.java
Form app = new Form(
    "Explore", new BorderLayout()
);

app.add(CENTER, buildContent());
app.add(SOUTH, buildTabs());
app.show();

iOS 27 · UIKit above Codename One · 60 fps

iOS 27 tab bars: UIKit above Codename One
Codename One Android Material 3 light and dark theme test capture
Real runtime captures iOS 27 tab gestures and Android Material 3.

Complete full-stack templates

Start with an application. Make it yours.

Generate the Java client, backend, database and administration screens in one project. Run it, change the branding and build on the features already connected. Template source is free under MIT-0.

Generate your application Explore all templates
Savor restaurant browsing screen

Food delivery

Savor

Customer, restaurant, courier and admin screens, with a Java backend for ordering, dispatch, tracking and payments.

Explore Savor →
Parley conversations screen

Private messaging

Parley

Chats, groups, voice and video calls, with a Java backend and an administration console.

Explore Parley →
Wayline rider map and destination screen

Ride hailing

Wayline

Rider, driver and admin screens, with a Java backend for matching, live trips, earnings and payments.

Explore Wayline →
Skirmish live battle screen

Multiplayer strategy

Skirmish

Online battles, replays and progression, with a Java game server and a moderation console.

Explore Skirmish →
Bastion account balances and dashboard

Virtual banking

Bastion

Customer accounts, transfers and a staff console, with a Java backend and double-entry ledger. Money and markets are simulated.

Explore Bastion →
Reel streaming catalog and continue-watching screen

Streaming and courses

Reel

A viewer app, creator studio, moderation and admin screens, with a Java backend for subscriptions, rentals and courses.

Explore Reel →

Choose your starting point

A new service. An existing Android app. A shared stack.

Start with the part you need. The app framework works with any backend, and the native backend can run on its own.

Java services without a deployed JVM

Write controllers, inject dependencies and use transactions. Compile the wiring into a native executable.

An evolving API with documented library support, not a drop-in Spring Boot replacement.

Build a native Java backend →

Serve browser pages with compiled HTML views and htmx.

Native executable size MiB · lower is better

CN1 native 5.17
Spring / GraalVM 25 88.31
Two-endpoint HTTP example. Uncompressed binaries; shared system libraries excluded. Measurements and source.

Your Android app on more platforms

Bring Java or Kotlin activities, XML layouts and resources to iOS, desktop and the web. Reuse supported Room DAOs, WorkManager jobs, location, sensors, foreground services and document pickers.

Room and background work have documented limits. Imported keystore keys do not preserve hardware-backed or user-authentication guarantees.

Explore Android compatibility →

The Android port also runs without Google Play Services, with runtime fallbacks and optional UnifiedPush. Play-dependent features still require their services.

Android / CN1Material gallery: Android framework at left, Codename One compatibility layer at right, both on Android 16
Same gallery · webImported Android gallery running in Chromium
Real captures. The paired comparison runs on Android 16. Try the browser build →

Keep app and server contracts together

Share Java models and generate typed REST clients. Change the contract in one place.

See the shared-model example →
shared /Java models
AppGenerated REST client
BackendTyped controller
One contract across the network. App-only and backend-only projects work independently, too.

Bring your existing code

Flutter, Swing, JavaFX and Compose. More places to run.

Compile supported application code into Codename One apps. Keep the screens you have, call the same platform and backend APIs, and add Java components alongside them.

Flutter from Dart source

Compile Dart to Java with Maven or Gradle and debug the original Dart. Supported widgets render through Codename One.

Gallery cold start Android emulator · ms · lower is better

CN1 395
Flutter 1,247

The same Dart source in matched release builds; idle memory was 46 vs 79 MB. October 29 measurements, not phone measurements.

Experimental: some callbacks and parameters are ignored. Test your app's interactions. iOS startup and memory are unmeasured.

Import Flutter code →

Compare all platforms and workloads →

Swing and JavaFX beyond desktop

Bring supported Swing, SwingX and JavaFX source to phones, desktop and web. FXML and JavaFX CSS compile at build time.

SwingSet2 download Linux · zipped MB · lower is better

CN1 native 8.2
App + jlink JVM 34.1

The JavaFX gallery downloads at 7.1 vs 39.1 MB. Same app sources; shared system libraries excluded. Its first paint takes 116 ms native vs 422 ms on a tuned JVM: median of seven Linux launches on a software framebuffer.

Supported API subsets. Third-party desktop JARs and runtime reflection need porting; unsupported calls fail the build.

Import Swing or JavaFX code →

Compare size, startup and memory →

Kotlin Multiplatform and Compose

Keep shared commonMain code and supported composables. Use the real Compose runtime over Codename One components, alongside Java.

State change to drawn Keynote app · ms · lower is better

CN1 Compose 4.58
Compose Multiplatform 19.24

Same Kotlin source, iPhone 17 Pro simulator, Xcode 27 on Apple silicon, five release runs. The separate imperative Java version takes 1.49 ms.

Simulator CPU work, not device frame rates. Check the supported composables and modifiers before porting.

Import Kotlin and Compose code →

Inspect the benchmark and harness →

Also available: experimental Unity 2D compatibility, with documented API and behavior limits.

Measured, with code you can run

Compare the runtime costs.

Published reference results against HotSpot, Spring and Go. These are separate workloads, with their hardware, methodology and limits linked below.

Compiler translation time JDK 25 = 100 · lower is better

ParparVM 62.5
JDK 25 100

37.5% less time

ParparVM translating its own compiler also used 45.8% less peak memory in the Linux ARM64 Neoverse N2 baseline, across seven calibration runs. Generated files were identical. Allocation-heavy workloads can favor HotSpot.

Inspect every workload and machine

Plaintext requests / second Higher is better

CN1 native 296,928
Spring / JDK 25 75,721

3.9× Spring’s throughput

Spring Boot 4.1.1 / JDK 25. Two pinned CPUs, Linux ARM64 VM on M4 Max, 32 connections, matched 60-second warmup.

HTTP handlers only: no database, TLS, authentication or generated controllers.

Reproduce the Spring comparison

Plaintext requests / second Separate Go comparison · higher is better

CN1 native musl 595,610
Go fasthttp 496,293

Compare with Go

Two pinned cores, 64 connections, medians of three interleaved runs. Go used less memory and a smaller binary.

Compare throughput, startup and memory

Crypto in the app and server

Wallet APIs. Native kernels. Parallel verification.

Build Ethereum/EVM, Bitcoin and Solana wallets with shared Java APIs for key derivation, transaction signing and node access.

Use the CPU cores and GPU

Native kernels accelerate signatures and hashes. CryptoBatch distributes verification across CPU cores, with Metal, Vulkan or WebGPU batches on supported devices. GPU work uses public data, never private keys.

On an ARM64 API 36 Android emulator, native ECDSA verification measured 6.00× BouncyCastle. GPU gains vary with the device and batch size; portable Java paths cover other environments.

Explore wallets and async crypto APIs →

Ed25519 verifications / second Single-operation native test · higher is better

CN1 native 39,129
OpenSSL 3.6.3 17,521
M4 Max, matched compiler flags: 2.23× for this operation. Some hash workloads favor the reference. Multi-core batch ratios use a serial reference and are not single-core speedups. All kernels, GPU results and reproduction commands →

Own the result

The screen you test is the screen you ship.

Codename One draws its own components. The runtime and theme are packaged with the application, so an OS update does not silently swap in a different widget implementation.

Native iOS 26 and Codename One tab states, in light and dark themes Codename One Material 3 theme in light and dark appearance
Liquid Glass and Material 3, captured from the running UI. Explore the themes →

Control the pixels

Theme the shared UI with CSS, draw directly when you need to, and keep brand behavior consistent across targets.

Ship one behavior

Fix shared application logic and UI once instead of maintaining separate screen implementations for each platform.

Drop to native when it matters

Call platform SDKs through native interfaces. Embed a map, web view, camera surface, or other heavyweight view with PeerComponent.

The build path

Java in. Native applications out.

Use Maven or Gradle and your existing IDE. Codename One supplies the portable runtime, platform ports, and build tooling.

SourceJava + CSS
Develop locallySimulator + tests
BuildNative / JavaScript
  1. 1

    Write the application once

    Keep your application logic, UI and optional backend in one project, with shared models where they help.

    Start the project
  2. 2

    Run and inspect locally

    The simulator provides device skins, component and network inspectors, test recording, and live CSS.

    See the development tools
  3. 3

    Build with native toolchains

    Generate platform projects or use the cloud service to build app-store binaries, including iOS builds without a Mac.

    Submit your first native build

Agentic development

Let the agent see what it built.

Generated projects include agent instructions. Connect Codex, Claude Code or another MCP host to inspect and operate the running simulator.

Connect an agent Read the MCP implementation
01 · EditJava source
02 · VerifyCompiler + tests
03 · InspectLive UI via MCP
↶ UI state and test results inform the next edit.

MCP also connects to native development builds on ports with server sockets, including Linux. Device connections need forwarding; release builds block access by default.

Deployment targets

One Java project. Every screen.

Phones, desktops, browsers, watches and TV, with a native backend for the server. See Port Status for supported versions, architectures and test evidence.

Inspect every port and test
  • Android Phones & tablets
  • iOS and iPadOS iPhone & iPad
  • macOS Native desktop
  • Web Browser JavaScript
  • Linux Native desktop
  • Windows Native desktop
  • watchOS Apple Watch
  • tvOS Apple TV
  • Vehicle integrations CarPlay and Android Auto
  • System surfaces Widgets, Live Activities, Dynamic Island
  • Native backendJava services & serverless
  • Android surfacesWear OS & Android TV

Engineering notes

Read the mechanisms, not a brochure.

All engineering posts

Start with the real thing

Create the project. Build it your way.

Generate a Maven project and build with your own tools, or use cloud builds for iOS without a Mac. A free account includes 100 cloud build credits each month.

Create a Java project Try it in your browser Follow the build guide