Skip to main content

COBOL on Miren

If it compiles to a program that can write bytes to a socket, Miren can run it — COBOL included. COBOL has no built-in HTTP server, so this guide compiles a COBOL program with GnuCOBOL that prints a complete HTTP response, and puts socat in front of it to handle the socket.

Let your agent do this

Ask your AI coding agent to "set up this COBOL program on Miren" after installing the Miren agent skills. It adds the Dockerfile.miren and the socket front-end, and deploys — using this page as its reference.

Do you need a Dockerfile?​

Yes. Add a Dockerfile.miren to your project root. Miren builds from it instead of guessing the stack — see Using Dockerfile.miren.

Want native support?

Miren auto-detects and builds common stacks (Python, Node, Bun, Go, Ruby, Rust) without a Dockerfile. This language isn't one of them yet — if you'd like first-class support, request it.

The program​

The COBOL program writes a full HTTP response — status line, headers, a blank line, then the body — to standard output. X"0D0A" is CRLF:

       IDENTIFICATION DIVISION.
       PROGRAM-ID. hello.
       DATA DIVISION.
       WORKING-STORAGE SECTION.
       01 CRLF PIC X(2) VALUE X"0D0A".
       PROCEDURE DIVISION.
           DISPLAY
               "HTTP/1.1 200 OK" CRLF
               "Content-Type: text/plain" CRLF
               "Connection: close" CRLF
               CRLF
               "Hello from COBOL on Miren!" CRLF
               WITH NO ADVANCING
           STOP RUN.

The socket front-end​

The program itself doesn't listen on a port — socat does. For each connection, socat runs the program and pipes its stdout back to the client. Miren injects PORT, and socat's TCP-LISTEN binds all interfaces:

web: socat TCP-LISTEN:$PORT,reuseaddr,fork EXEC:/app/hello

This socat pattern works for any language that can print an HTTP response to stdout.

Behind Miren's ingress

Miren's HTTP ingress terminates TLS and handles the public HTTP layer in front of your app, so socat only needs to hand each accepted connection to your program — it isn't exposed to raw internet traffic. The one practical limit is that fork spawns a process per request, so this suits low-traffic endpoints and tooling rather than high-throughput services.

The Dockerfile​

Create Dockerfile.miren in your project root. It installs GnuCOBOL and socat, then compiles the program:

FROM debian:12-slim

RUN apt-get update -y \
    && apt-get install -y gnucobol socat \
    && apt-get clean && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY hello.cob .
RUN cobc -x -o /app/hello hello.cob

EXPOSE 8080

.dockerignore​

.git

Deploy​

Create .miren/app.toml naming your app and deploy from your project root:

name = "cobol-bench"
miren deploy
The Procfile is required

Even with a Dockerfile.miren, Miren needs at least one service defined — the web: line above. Without it the deploy stops with no services defined.

Agent quick reference​

  • Detection: none — requires Dockerfile.miren
  • Build: cobc -x -o /app/hello hello.cob on debian:12-slim with gnucobol
  • Serving: the program prints a full HTTP response; socat handles the socket
  • Service is required: Procfile web: socat TCP-LISTEN:$PORT,reuseaddr,fork EXEC:/app/hello
  • Port: socat TCP-LISTEN:$PORT binds 0.0.0.0
  • Pattern: the same socat front-end works for any language that writes an HTTP response to stdout

Next steps​