LaunchPad

Deploy your Oorian application as a single executable JAR. LaunchPad wraps Jetty to provide a zero-configuration embedded server — no Tomcat, no Glassfish, just compile and run.

Features

Everything you need for standalone deployment.

Zero Configuration

Start your application with just a few lines of code. Sensible defaults for everything.

HTTP & HTTPS

Full HTTP and HTTPS support with easy SSL certificate configuration.

Full Communication

AJAX, SSE, and WebSocket all work out of the box. No extra configuration needed.

GZIP Compression

Automatic response compression for faster page loads and reduced bandwidth.

Health Endpoint

Built-in health check endpoint for monitoring and load balancer integration.

Built-in Monitoring

JMX support out of the box, optional Prometheus metrics endpoint for production observability.

Hot Restart

IDE-friendly hot restart support for rapid development cycles. No port conflicts.

Microservice Ready

Lightweight footprint with fast startup times. Perfect for microservice architectures.

Single JAR Deployment

Package your entire application as a single executable JAR. No WAR files needed.

Up and Running in 5 Lines

Create a launcher class, set the port, and launch your Oorian application. Run the main method and browse to http://localhost:8080.

java
public class MyLauncher
{
    public static void main(String[] args)
    {
        LaunchPad launcher = new LaunchPad();
        launcher.setPort(8080);
        launcher.launch(MyWebApp.class);
    }
}

Configuration Options

LaunchPad provides a fluent API for configuring your embedded server.

java
LaunchPad launcher = new LaunchPad();

// Basic configuration
launcher.setPort(8080)                           // HTTP port (default: 8080)
        .setContextPath("/myapp")                // Context path (default: /)
        .setShutdownPort(8005);                  // Shutdown port for IDE restart

// SSL/HTTPS
launcher.enableSsl("/path/to/keystore.jks", "password")
        .setSslPort(8443);                       // HTTPS port (default: 8443)

// Thread pool
launcher.setThreadPool(10, 200)                  // Min and max threads
        .setIdleTimeout(30000);                  // Connection idle timeout in ms

// Features
launcher.setGzipEnabled(true)                    // GZIP compression (default: true)
        .setHealthEndpointEnabled(true)          // Health check endpoint (default: true)
        .setHealthEndpointPath("/health");       // Health endpoint path

// Static resources
launcher.setResourceBase("/var/www/static")      // Serve static files
        .setTempDirectory("/tmp/myapp");         // Temp directory for uploads

// Configuration file (optional)
launcher.setConfigFile("/etc/myapp/server.properties");

launcher.launch(MyApplication.class);

Configuration File

For production deployments, you can externalize configuration to a properties file.

properties
# server.properties
server.port=8080
server.shutdown.port=8005
server.context.path=/
server.threads.min=10
server.threads.max=200
server.idle.timeout=30000

# SSL (optional)
server.ssl.enabled=true
server.ssl.port=8443
server.ssl.keystore=/etc/myapp/keystore.jks
server.ssl.keystore.password=changeit
server.ssl.key.password=changeit

# Features
server.gzip.enabled=true
server.health.enabled=true
server.health.path=/health

# Resources
server.resource.base=/var/www/myapp/static
server.temp.directory=/tmp/myapp

# Access Logging
server.accesslog.enabled=true
server.accesslog.path=/var/log/myapp/access.log

Why Use LaunchPad?

Simplified Deployment

No need to install and configure Tomcat, Jetty, or any other servlet container. Your application is self-contained.

Container-Ready

Perfect for Docker deployments. Just build a JAR with dependencies and run it. The health endpoint makes Kubernetes integration seamless.

Development Friendly

The shutdown port mechanism automatically stops the previous instance when you restart from your IDE. No more 'port already in use' errors.

Production Proven

Built on Jetty, one of the most battle-tested embedded servers. LaunchPad adds a simple API on top without sacrificing reliability.

Flexible Configuration

Configure programmatically for development, via properties files for production, or mix both approaches as needed.

Full Feature Support

All Oorian features work with LaunchPad: AJAX, SSE, WebSocket, file uploads, sessions, and more.

Coming Q1 2026

Download

LaunchPad will be available for download with the initial Q1 2026 release.

What's Included

  • launchpad.jar
  • Embedded Jetty runtime
  • Configuration templates
  • Sample projects

Ready to Deploy?

Deploy your Oorian application as a single JAR — no external server required.