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.

Open source on GitHub Read the source, issues, and discussions
New releases every week Inspect the tags and release notes
Port status backed by CI Check current test evidence for every target
From indie developers to enterprise teams Trusted by major banks, telecom operators and game developers

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

Food delivery

Savor

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

Explore Savor →

Private messaging

Parley

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

Explore Parley →

Ride hailing

Wayline

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

Explore Wayline →

Multiplayer strategy

Skirmish

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

Explore Skirmish →

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.

Check your dependencies against the supported Android and AndroidX APIs.

Explore Android compatibility →

Experimental imports: Flutter screens and Unity 2D games. Check the documented API and behavior limits before porting.

Material gallery: Android framework at left, Codename One compatibility layer at right, both on Android 16 — Real captures. The paired comparison runs on Android 16. Try the browser build →

Imported 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.

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

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 — Liquid Glass and Material 3, captured from the running UI. Explore the 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
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
Run and inspect locally
The simulator provides device skins, component and network inspectors, test recording, and live CSS.
See the development tools
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

October 25, 2026

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

Full-stack Java.
Compiled to native.